diff --git a/BoardConfigCommon.mk b/BoardConfigCommon.mk index 0d191cf8..3c2a5e5d 100644 --- a/BoardConfigCommon.mk +++ b/BoardConfigCommon.mk @@ -11,7 +11,6 @@ COMMON_PATH := device/xiaomi/sdm660-common PRODUCT_USES_QCOM_HARDWARE := true PRODUCT_BOARD_PLATFORM := sdm660 OVERRIDE_QCOM_HARDWARE_VARIANT := sdm660 -BOARD_VENDOR := xiaomi # A/B ifeq ($(ENABLE_AB), true) diff --git a/configs/perf/perf-profile0.conf b/configs/perf/perf-profile0.conf new file mode 100644 index 00000000..0c358e14 --- /dev/null +++ b/configs/perf/perf-profile0.conf @@ -0,0 +1,2 @@ +[priority] # This profile is reserved for perflock requests +99 diff --git a/configs/perf/perfconfigstore.xml b/configs/perf/perfconfigstore.xml new file mode 100644 index 00000000..ee4ea350 --- /dev/null +++ b/configs/perf/perfconfigstore.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + diff --git a/configs/public.libraries.txt b/configs/public.libraries.txt index 048e733b..555be3f5 100644 --- a/configs/public.libraries.txt +++ b/configs/public.libraries.txt @@ -1,3 +1,4 @@ +libqti-perfd-client.so libadsprpc.so libcdsprpc.so libsdsprpc.so diff --git a/libqti-perfd-client/Android.bp b/libqti-perfd-client/Android.bp index ae75b9dd..1c8e2824 100644 --- a/libqti-perfd-client/Android.bp +++ b/libqti-perfd-client/Android.bp @@ -1,15 +1,17 @@ -// -// Copyright (C) 2021-2022 The LineageOS Project -// -// SPDX-License-Identifier: Apache-2.0 -// - cc_library_shared { name: "libqti-perfd-client", - vendor: true, - srcs: ["client.c"], + proprietary: true, + defaults: ["hidl_defaults"], + srcs: [ + "client.c", + ], + cflags: [ + "-Werror", + "-Wextra", + "-Wall", + ], shared_libs: [ - "liblog", "libutils", + "liblog", ], } diff --git a/libqti-perfd-client/client.c b/libqti-perfd-client/client.c index 66e75b49..42b3cdcd 100644 --- a/libqti-perfd-client/client.c +++ b/libqti-perfd-client/client.c @@ -1,9 +1,3 @@ -/* - * Copyright (C) 2021 The LineageOS Project - * - * SPDX-License-Identifier: Apache-2.0 - */ - #define LOG_TAG "libqti-perfd-client" #include diff --git a/manifest.xml b/manifest.xml index 40ac7169..c7147361 100755 --- a/manifest.xml +++ b/manifest.xml @@ -187,6 +187,11 @@ hwbinder @1.0::IDspService/dspservice + + vendor.qti.hardware.perf + hwbinder + @2.2::IPerf/default + vendor.qti.hardware.qseecom hwbinder diff --git a/power-libperfmgr/Android.bp b/power-libperfmgr/Android.bp new file mode 100644 index 00000000..78d4029a --- /dev/null +++ b/power-libperfmgr/Android.bp @@ -0,0 +1,117 @@ +// +// Copyright (C) 2018 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package { + default_applicable_licenses: ["Android-Apache-2.0"], +} + +cc_library { + name: "libdisppower-xiaomi_sdm660", + proprietary: true, + srcs: [ + "disp-power/InteractionHandler.cpp", + ], + shared_libs: [ + "libbase", + "libcutils", + "liblog", + "libperfmgr", + "libutils", + ], +} + +cc_library { + name: "libadaptivecpu-xiaomi_sdm660", + proprietary: true, + vendor: true, + srcs: [ + "adaptivecpu/AdaptiveCpu.cpp", + "adaptivecpu/AdaptiveCpuConfig.cpp", + "adaptivecpu/AdaptiveCpuStats.cpp", + "adaptivecpu/CpuFrequencyReader.cpp", + "adaptivecpu/CpuLoadReaderProcStat.cpp", + "adaptivecpu/CpuLoadReaderSysDevices.cpp", + "adaptivecpu/Device.cpp", + "adaptivecpu/KernelCpuFeatureReader.cpp", + "adaptivecpu/Model.cpp", + "adaptivecpu/RealFilesystem.cpp", + "adaptivecpu/ThrottleDecision.cpp", + "adaptivecpu/TimeSource.cpp", + "adaptivecpu/WorkDurationProcessor.cpp", + ], + shared_libs: [ + "android.hardware.power-V3-ndk", + "libbase", + "liblog", + "libperfmgr", + "libutils", + "libcutils", + ], +} + +cc_test { + name: "libadaptivecpu_test-xiaomi_sdm660", + proprietary: true, + vendor: true, + srcs: [ + "adaptivecpu/tests/AdaptiveCpuConfigTest.cpp", + "adaptivecpu/tests/AdaptiveCpuStatsTest.cpp", + "adaptivecpu/tests/CpuFrequencyReaderTest.cpp", + "adaptivecpu/tests/CpuLoadReaderProcStatTest.cpp", + "adaptivecpu/tests/CpuLoadReaderSysDevicesTest.cpp", + "adaptivecpu/tests/KernelCpuFeatureReaderTest.cpp", + "adaptivecpu/tests/ModelTest.cpp", + "adaptivecpu/tests/WorkDurationProcessorTest.cpp", + ], + static_libs: [ + "libadaptivecpu-xiaomi_sdm660", + "libgmock", + "android.hardware.power-V3-ndk", + ], + shared_libs: [ + "liblog", + "libbase", + "libcutils", + ], + test_suites: ["device-tests"], +} + +cc_binary { + name: "android.hardware.power-service.xiaomi_sdm660-libperfmgr", + relative_install_path: "hw", + init_rc: ["aidl/android.hardware.power-service.xiaomi_sdm660-libperfmgr.rc"], + vintf_fragments: ["aidl/android.hardware.power-service.xiaomi_sdm660.xml"], + vendor: true, + shared_libs: [ + "android.hardware.power-V3-ndk", + "libadaptivecpu-xiaomi_sdm660", + "libbase", + "libcutils", + "liblog", + "libutils", + "libbinder_ndk", + "libdisppower-xiaomi_sdm660", + "libperfmgr", + "libprocessgroup", + "pixel-power-ext-V1-ndk", + ], + srcs: [ + "aidl/service.cpp", + "aidl/Power.cpp", + "aidl/PowerExt.cpp", + "aidl/PowerHintSession.cpp", + "aidl/PowerSessionManager.cpp", + ], +} diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpu.cpp b/power-libperfmgr/adaptivecpu/AdaptiveCpu.cpp new file mode 100644 index 00000000..0ad96399 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/AdaptiveCpu.cpp @@ -0,0 +1,233 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "AdaptiveCpu.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "CpuLoadReaderSysDevices.h" +#include "Model.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using ::android::perfmgr::HintManager; + +// We pass the previous N ModelInputs to the model, including the most recent ModelInput. +constexpr uint32_t kNumHistoricalModelInputs = 3; + +// TODO(b/207662659): Add config for changing between different reader types. +AdaptiveCpu::AdaptiveCpu() {} + +bool AdaptiveCpu::IsEnabled() const { + return mIsEnabled; +} + +void AdaptiveCpu::HintReceived(bool enable) { + ATRACE_CALL(); + LOG(INFO) << "AdaptiveCpu received hint: enable=" << enable; + if (enable) { + StartThread(); + } else { + SuspendThread(); + } +} + +void AdaptiveCpu::StartThread() { + ATRACE_CALL(); + std::lock_guard lock(mThreadCreationMutex); + LOG(INFO) << "Starting AdaptiveCpu thread"; + mIsEnabled = true; + mShouldReloadConfig = true; + mLastEnabledHintTime = mTimeSource.GetTime(); + if (!mLoopThread.joinable()) { + mLoopThread = std::thread([&]() { + pthread_setname_np(pthread_self(), "AdaptiveCpu"); + // Parent threads may have higher priorities, so we reset to the default. + int ret = setpriority(PRIO_PROCESS, 0, 0); + if (ret != 0) { + PLOG(ERROR) << "setpriority on AdaptiveCpu thread failed: " << ret; + } + LOG(INFO) << "Started AdaptiveCpu thread successfully"; + RunMainLoop(); + LOG(ERROR) << "AdaptiveCpu thread ended, this should never happen!"; + }); + } +} + +void AdaptiveCpu::SuspendThread() { + ATRACE_CALL(); + LOG(INFO) << "Stopping AdaptiveCpu thread"; + // This stops the thread from receiving work durations in ReportWorkDurations, which means the + // thread blocks indefinitely. + mIsEnabled = false; +} + +void AdaptiveCpu::ReportWorkDurations(const std::vector &workDurations, + std::chrono::nanoseconds targetDuration) { + ATRACE_CALL(); + if (!mIsEnabled) { + return; + } + if (!mWorkDurationProcessor.ReportWorkDurations(workDurations, targetDuration)) { + mIsEnabled = false; + return; + } + mWorkDurationsAvailableCondition.notify_one(); +} + +void AdaptiveCpu::WaitForEnabledAndWorkDurations() { + ATRACE_CALL(); + std::unique_lock lock(mWaitMutex); + // TODO(b/188770301) Once the gating logic is implemented, don't block indefinitely. + mWorkDurationsAvailableCondition.wait( + lock, [&] { return mIsEnabled && mWorkDurationProcessor.HasWorkDurations(); }); +} + +void AdaptiveCpu::RunMainLoop() { + ATRACE_CALL(); + + std::deque historicalModelInputs; + ThrottleDecision previousThrottleDecision = ThrottleDecision::NO_THROTTLE; + while (true) { + ATRACE_NAME("loop"); + WaitForEnabledAndWorkDurations(); + + if (mLastEnabledHintTime + mConfig.enabledHintTimeout < mTimeSource.GetTime()) { + LOG(INFO) << "Adaptive CPU hint timed out, last enabled time=" + << mLastEnabledHintTime.count() << "ns"; + mIsEnabled = false; + continue; + } + + if (mShouldReloadConfig) { + if (!AdaptiveCpuConfig::ReadFromSystemProperties(&mConfig)) { + mIsEnabled = false; + continue; + } + LOG(INFO) << "Read config: " << mConfig; + mShouldReloadConfig = false; + } + + ATRACE_BEGIN("compute"); + mAdaptiveCpuStats.RegisterStartRun(); + + if (!mIsInitialized) { + if (!mKernelCpuFeatureReader.Init()) { + mIsEnabled = false; + continue; + } + mDevice = ReadDevice(); + mIsInitialized = true; + } + + ModelInput modelInput; + modelInput.previousThrottleDecision = previousThrottleDecision; + + modelInput.workDurationFeatures = mWorkDurationProcessor.GetFeatures(); + LOG(VERBOSE) << "Got work durations: count=" << modelInput.workDurationFeatures.numDurations + << ", average=" << modelInput.workDurationFeatures.averageDuration.count() + << "ns"; + if (modelInput.workDurationFeatures.numDurations == 0) { + continue; + } + + if (!mKernelCpuFeatureReader.GetRecentCpuFeatures(&modelInput.cpuPolicyAverageFrequencyHz, + &modelInput.cpuCoreIdleTimesPercentage)) { + mIsEnabled = false; + continue; + } + + modelInput.LogToAtrace(); + historicalModelInputs.push_back(modelInput); + if (historicalModelInputs.size() > kNumHistoricalModelInputs) { + historicalModelInputs.pop_front(); + } + + const ThrottleDecision throttleDecision = mModel.Run(historicalModelInputs, mConfig); + LOG(VERBOSE) << "Model decision: " << static_cast(throttleDecision); + ATRACE_INT("AdaptiveCpu_throttleDecision", static_cast(throttleDecision)); + + { + ATRACE_NAME("sendHints"); + const auto now = mTimeSource.GetTime(); + // Resend the throttle hints, even if they've not changed, if the previous send is close + // to timing out. We define "close to" as half the hint timeout, as we can't guarantee + // we will run again before the actual timeout. + const bool throttleHintMayTimeout = + now - mLastThrottleHintTime > mConfig.hintTimeout / 2; + if (throttleDecision != previousThrottleDecision || throttleHintMayTimeout) { + ATRACE_NAME("sendNewHints"); + mLastThrottleHintTime = now; + for (const auto &hintName : THROTTLE_DECISION_TO_HINT_NAMES.at(throttleDecision)) { + HintManager::GetInstance()->DoHint(hintName, mConfig.hintTimeout); + } + } + if (throttleDecision != previousThrottleDecision) { + ATRACE_NAME("endOldHints"); + for (const auto &hintName : + THROTTLE_DECISION_TO_HINT_NAMES.at(previousThrottleDecision)) { + HintManager::GetInstance()->EndHint(hintName); + } + previousThrottleDecision = throttleDecision; + } + } + + mAdaptiveCpuStats.RegisterSuccessfulRun(previousThrottleDecision, throttleDecision, + modelInput.workDurationFeatures, mConfig); + ATRACE_END(); // compute + { + ATRACE_NAME("sleep"); + std::this_thread::sleep_for(mConfig.iterationSleepDuration); + } + } +} + +void AdaptiveCpu::DumpToFd(int fd) const { + std::stringstream result; + result << "========== Begin Adaptive CPU stats ==========\n"; + result << "Enabled: " << mIsEnabled << "\n"; + result << "Config: " << mConfig << "\n"; + mKernelCpuFeatureReader.DumpToStream(result); + mAdaptiveCpuStats.DumpToStream(result); + result << "========== End Adaptive CPU stats ==========\n"; + if (!::android::base::WriteStringToFd(result.str(), fd)) { + PLOG(ERROR) << "Failed to dump state to fd"; + } +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpu.h b/power-libperfmgr/adaptivecpu/AdaptiveCpu.h new file mode 100644 index 00000000..4ab83c52 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/AdaptiveCpu.h @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +#include +#include +#include +#include + +#include "AdaptiveCpuConfig.h" +#include "AdaptiveCpuStats.h" +#include "Device.h" +#include "KernelCpuFeatureReader.h" +#include "Model.h" +#include "WorkDurationProcessor.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using std::chrono_literals::operator""ms; +using ::aidl::android::hardware::power::WorkDuration; +using ::android::perfmgr::HintManager; + +// Applies CPU frequency hints infered by an ML model based on the recent CPU statistics and work +// durations. +// This class's public members are not synchronised and should not be used from multiple threads, +// with the exception of ReportWorkDuration, which can be called from an arbitrary thread. +class AdaptiveCpu { + public: + AdaptiveCpu(); + + bool IsEnabled() const; + + // Called when the Adaptive CPU hint is received. This method enables/disables the Adaptive CPU + // thread. + void HintReceived(bool enable); + + // Reports work durations for processing. This method returns immediately as work durations are + // processed asynchonuously. + void ReportWorkDurations(const std::vector &workDurations, + std::chrono::nanoseconds targetDuration); + + // Dump info to a file descriptor. Called when dumping service info. + void DumpToFd(int fd) const; + + // When PowerExt receives a hint with this name, HintReceived() is called. + static constexpr char HINT_NAME[] = "ADAPTIVE_CPU"; + + private: + void StartThread(); + + void SuspendThread(); + + // The main loop of Adaptive CPU, which runs in a separate thread. + void RunMainLoop(); + + void WaitForEnabledAndWorkDurations(); + + Model mModel; + WorkDurationProcessor mWorkDurationProcessor; + KernelCpuFeatureReader mKernelCpuFeatureReader; + AdaptiveCpuStats mAdaptiveCpuStats; + const TimeSource mTimeSource; + + // The thread in which work durations are processed. + std::thread mLoopThread; + + // Guards against creating multiple threads in the case HintReceived(true) is called on separate + // threads simultaneously. + std::mutex mThreadCreationMutex; + // Used when waiting in WaitForEnabledAndWorkDurations(). + std::mutex mWaitMutex; + + // A condition variable that will be notified when new work durations arrive. + std::condition_variable mWorkDurationsAvailableCondition; + + volatile bool mIsEnabled = false; + bool mIsInitialized = false; + volatile bool mShouldReloadConfig = false; + std::chrono::nanoseconds mLastEnabledHintTime; + std::chrono::nanoseconds mLastThrottleHintTime; + Device mDevice; + AdaptiveCpuConfig mConfig = AdaptiveCpuConfig::DEFAULT; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.cpp b/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.cpp new file mode 100644 index 00000000..5a8428d1 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.cpp @@ -0,0 +1,174 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "AdaptiveCpuConfig.h" + +#include +#include +#include +#include + +#include +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using std::chrono_literals::operator""ms; +using std::chrono_literals::operator""min; + +constexpr std::string_view kIterationSleepDurationProperty( + "debug.adaptivecpu.iteration_sleep_duration_ms"); +static const std::chrono::milliseconds kIterationSleepDurationMin = 20ms; +constexpr std::string_view kHintTimeoutProperty("debug.adaptivecpu.hint_timeout_ms"); +// "percent" as range is 0-100, while the in-memory is "probability" as range is 0-1. +constexpr std::string_view kRandomThrottleDecisionPercentProperty( + "debug.adaptivecpu.random_throttle_decision_percent"); +constexpr std::string_view kRandomThrottleOptionsProperty( + "debug.adaptivecpu.random_throttle_options"); +constexpr std::string_view kEnabledHintTimeoutProperty("debug.adaptivecpu.enabled_hint_timeout_ms"); + +bool ParseThrottleDecisions(const std::string &input, std::vector *output); +std::string FormatThrottleDecisions(const std::vector &throttleDecisions); + +const AdaptiveCpuConfig AdaptiveCpuConfig::DEFAULT{ + // N.B.: The model will typically be trained with this value set to 25ms. We set it to 1s as + // a safety measure, but best performance will be seen at 25ms. + .iterationSleepDuration = 1000ms, + .hintTimeout = 2000ms, + .randomThrottleDecisionProbability = 0, + .randomThrottleOptions = {ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_50, + ThrottleDecision::THROTTLE_60, ThrottleDecision::THROTTLE_70, + ThrottleDecision::THROTTLE_80, ThrottleDecision::THROTTLE_90}, + .enabledHintTimeout = 120min, +}; + +bool AdaptiveCpuConfig::ReadFromSystemProperties(AdaptiveCpuConfig *output) { + ATRACE_CALL(); + + output->iterationSleepDuration = std::chrono::milliseconds( + ::android::base::GetUintProperty(kIterationSleepDurationProperty.data(), + DEFAULT.iterationSleepDuration.count())); + output->iterationSleepDuration = + std::max(output->iterationSleepDuration, kIterationSleepDurationMin); + + output->hintTimeout = std::chrono::milliseconds(::android::base::GetUintProperty( + kHintTimeoutProperty.data(), DEFAULT.hintTimeout.count())); + + output->randomThrottleDecisionProbability = + static_cast(::android::base::GetUintProperty( + kRandomThrottleDecisionPercentProperty.data(), + DEFAULT.randomThrottleDecisionProbability * 100)) / + 100; + if (output->randomThrottleDecisionProbability > 1.0) { + LOG(ERROR) << "Received bad value for " << kRandomThrottleDecisionPercentProperty << ": " + << output->randomThrottleDecisionProbability; + return false; + } + + const std::string randomThrottleOptionsStr = + ::android::base::GetProperty(kRandomThrottleOptionsProperty.data(), + FormatThrottleDecisions(DEFAULT.randomThrottleOptions)); + output->randomThrottleOptions.clear(); + if (!ParseThrottleDecisions(randomThrottleOptionsStr, &output->randomThrottleOptions)) { + return false; + } + + output->enabledHintTimeout = + std::chrono::milliseconds(::android::base::GetUintProperty( + kEnabledHintTimeoutProperty.data(), DEFAULT.enabledHintTimeout.count())); + + return true; +} + +bool AdaptiveCpuConfig::operator==(const AdaptiveCpuConfig &other) const { + return iterationSleepDuration == other.iterationSleepDuration && + hintTimeout == other.hintTimeout && + randomThrottleDecisionProbability == other.randomThrottleDecisionProbability && + enabledHintTimeout == other.enabledHintTimeout && + randomThrottleOptions == other.randomThrottleOptions; +} + +std::ostream &operator<<(std::ostream &stream, const AdaptiveCpuConfig &config) { + stream << "AdaptiveCpuConfig("; + stream << "iterationSleepDuration=" << config.iterationSleepDuration.count() << "ms, "; + stream << "hintTimeout=" << config.hintTimeout.count() << "ms, "; + stream << "randomThrottleDecisionProbability=" << config.randomThrottleDecisionProbability + << ", "; + stream << "enabledHintTimeout=" << config.enabledHintTimeout.count() << "ms, "; + stream << "randomThrottleOptions=[" << FormatThrottleDecisions(config.randomThrottleOptions) + << "]"; + stream << ")"; + return stream; +} + +bool ParseThrottleDecisions(const std::string &input, std::vector *output) { + std::stringstream ss(input); + while (ss.good()) { + std::string throttleDecisionStr; + if (std::getline(ss, throttleDecisionStr, ',').fail()) { + LOG(ERROR) << "Failed to getline on throttle decisions string: " << input; + return false; + } + uint32_t throttleDecisionInt; + int scanEnd; + if (std::sscanf(throttleDecisionStr.c_str(), "%" PRIu32 "%n", &throttleDecisionInt, + &scanEnd) != 1 || + scanEnd != throttleDecisionStr.size()) { + LOG(ERROR) << "Failed to parse as int: str=" << throttleDecisionStr + << ", input=" << input << ", scanEnd=" << scanEnd; + return false; + } + if (throttleDecisionInt < static_cast(ThrottleDecision::FIRST) || + throttleDecisionInt > static_cast(ThrottleDecision::LAST)) { + LOG(ERROR) << "Failed to parse throttle decision: throttleDecision=" + << throttleDecisionInt << ", input=" << input; + return false; + } + output->push_back(static_cast(throttleDecisionInt)); + } + if (output->empty()) { + LOG(ERROR) << "Failed to find any throttle decisions, must have at least one: " << input; + return false; + } + return true; +} + +std::string FormatThrottleDecisions(const std::vector &throttleDecisions) { + std::stringstream ss; + for (size_t i = 0; i < throttleDecisions.size(); i++) { + ss << static_cast(throttleDecisions[i]); + if (i < throttleDecisions.size() - 1) { + ss << ","; + } + } + return ss.str(); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.h b/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.h new file mode 100644 index 00000000..59bef4c9 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +#include "ThrottleDecision.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +struct AdaptiveCpuConfig { + static bool ReadFromSystemProperties(AdaptiveCpuConfig *output); + static const AdaptiveCpuConfig DEFAULT; + + // How long to sleep for between Adaptive CPU runs. + std::chrono::milliseconds iterationSleepDuration; + // Timeout applied to hints. If Adaptive CPU doesn't receive any frames in this time, CPU + // throttling hints are cancelled. + std::chrono::milliseconds hintTimeout; + // Instead of throttling based on model output, choose a random throttle X% of the time. Must be + // between 0 and 1 inclusive. + double randomThrottleDecisionProbability; + std::vector randomThrottleOptions; + // Setting AdaptiveCpu to enabled only lasts this long. For a continuous run, AdaptiveCpu needs + // to receive the enabled hint more frequently than this value. + std::chrono::milliseconds enabledHintTimeout; + + bool operator==(const AdaptiveCpuConfig &other) const; +}; + +std::ostream &operator<<(std::ostream &os, const AdaptiveCpuConfig &config); + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.cpp b/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.cpp new file mode 100644 index 00000000..491683b8 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.cpp @@ -0,0 +1,131 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "AdaptiveCpuStats.h" + +#include + +#include "AdaptiveCpu.h" + +using std::chrono_literals::operator""ns; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +void AdaptiveCpuStats::RegisterStartRun() { + ATRACE_CALL(); + mNumStartedRuns++; + mLastRunStartTime = mTimeSource->GetTime(); + if (mStartTime == 0ns) { + mStartTime = mLastRunStartTime; + } +} + +void AdaptiveCpuStats::RegisterSuccessfulRun(ThrottleDecision previousThrottleDecision, + ThrottleDecision throttleDecision, + WorkDurationFeatures workDurationFeatures, + const AdaptiveCpuConfig &config) { + ATRACE_CALL(); + mNumSuccessfulRuns++; + mNumThrottles[throttleDecision]++; + const auto runSuccessTime = mTimeSource->GetTime(); + mTotalRunDuration += runSuccessTime - mLastRunStartTime; + // Don't update previousThrottleDecision entries if we haven't run successfully before. + if (mLastRunSuccessTime != 0ns) { + mThrottleDurations[previousThrottleDecision] += + std::min(runSuccessTime - mLastRunSuccessTime, + std::chrono::duration_cast(config.hintTimeout)); + mNumDurations[previousThrottleDecision] += workDurationFeatures.numDurations; + mNumMissedDeadlines[previousThrottleDecision] += workDurationFeatures.numMissedDeadlines; + } + mLastRunSuccessTime = runSuccessTime; +} + +void AdaptiveCpuStats::DumpToStream(std::ostream &stream) const { + stream << "Stats:\n"; + stream << "- Successful runs / total runs: " << mNumSuccessfulRuns << " / " << mNumStartedRuns + << "\n"; + stream << "- Total run duration: " << FormatDuration(mTotalRunDuration) << "\n"; + stream << "- Average run duration: " << FormatDuration(mTotalRunDuration / mNumSuccessfulRuns) + << "\n"; + stream << "- Running time fraction: " + << static_cast(mTotalRunDuration.count()) / + (mTimeSource->GetTime() - mStartTime).count() + << "\n"; + + stream << "- Number of throttles:\n"; + size_t totalNumThrottles = 0; + for (const auto &[throttleDecision, numThrottles] : mNumThrottles) { + stream << " - " << ThrottleString(throttleDecision) << ": " << numThrottles << "\n"; + totalNumThrottles += numThrottles; + } + stream << " - Total: " << totalNumThrottles << "\n"; + + stream << "- Time spent throttling:\n"; + std::chrono::nanoseconds totalThrottleDuration; + for (const auto &[throttleDecision, throttleDuration] : mThrottleDurations) { + stream << " - " << ThrottleString(throttleDecision) << ": " + << FormatDuration(throttleDuration) << "\n"; + totalThrottleDuration += throttleDuration; + } + stream << " - Total: " << FormatDuration(totalThrottleDuration) << "\n"; + + stream << "- Missed deadlines per throttle:\n"; + size_t totalNumDurations = 0; + size_t totalNumMissedDeadlines = 0; + for (const auto &[throttleDecision, numDurations] : mNumDurations) { + const size_t numMissedDeadlines = mNumMissedDeadlines.at(throttleDecision); + stream << " - " << ThrottleString(throttleDecision) << ": " << numMissedDeadlines << " / " + << numDurations << " (" << static_cast(numMissedDeadlines) / numDurations + << ")\n"; + totalNumDurations += numDurations; + totalNumMissedDeadlines += numMissedDeadlines; + } + stream << " - Total: " << totalNumMissedDeadlines << " / " << totalNumDurations << " (" + << static_cast(totalNumMissedDeadlines) / totalNumDurations << ")\n"; +} + +std::string AdaptiveCpuStats::FormatDuration(std::chrono::nanoseconds duration) { + double count = static_cast(duration.count()); + std::string suffix; + if (count < 1000.0) { + suffix = "ns"; + } else if (count < 1000.0 * 1000) { + suffix = "us"; + count /= 1000; + } else if (count < 1000.0 * 1000 * 100) { + suffix = "ms"; + count /= 1000 * 1000; + } else { + suffix = "s"; + count /= 1000 * 1000 * 1000; + } + return std::to_string(count) + suffix; +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.h b/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.h new file mode 100644 index 00000000..0c4a7f9f --- /dev/null +++ b/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +#include "AdaptiveCpuConfig.h" +#include "ITimeSource.h" +#include "Model.h" +#include "TimeSource.h" +#include "WorkDurationProcessor.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +// Collects statistics about Adaptive CPU. +// These are only Used during a dumpsys to improve bug report quality. +class AdaptiveCpuStats { + public: + AdaptiveCpuStats() : mTimeSource(std::make_unique()) {} + AdaptiveCpuStats(std::unique_ptr timeSource) + : mTimeSource(std::move(timeSource)) {} + + void RegisterStartRun(); + void RegisterSuccessfulRun(ThrottleDecision previousThrottleDecision, + ThrottleDecision throttleDecision, + WorkDurationFeatures workDurationFeatures, + const AdaptiveCpuConfig &config); + void DumpToStream(std::ostream &stream) const; + + private: + const std::unique_ptr mTimeSource; + + size_t mNumStartedRuns = 0; + size_t mNumSuccessfulRuns = 0; + std::chrono::nanoseconds mStartTime; + std::chrono::nanoseconds mLastRunStartTime; + std::chrono::nanoseconds mLastRunSuccessTime; + std::chrono::nanoseconds mTotalRunDuration; + + std::map mNumThrottles; + std::map mThrottleDurations; + + std::map mNumDurations; + std::map mNumMissedDeadlines; + + static std::string FormatDuration(std::chrono::nanoseconds duration); +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuFrequencyReader.cpp b/power-libperfmgr/adaptivecpu/CpuFrequencyReader.cpp new file mode 100644 index 00000000..a15d1e36 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/CpuFrequencyReader.cpp @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "CpuFrequencyReader.h" + +#include +#include +#include + +#include +#include +#include + +using std::chrono_literals::operator""ms; + +constexpr std::string_view kCpuPolicyDirectory("/sys/devices/system/cpu/cpufreq"); + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +bool CpuFrequencyReader::Init() { + ATRACE_CALL(); + mCpuPolicyIds.clear(); + if (!ReadCpuPolicyIds(&mCpuPolicyIds)) { + return false; + } + mPreviousCpuPolicyFrequencies.clear(); + return ReadCpuPolicyFrequencies(&mPreviousCpuPolicyFrequencies); +} + +bool CpuFrequencyReader::GetRecentCpuPolicyFrequencies( + std::vector *result) { + ATRACE_CALL(); + std::map> cpuPolicyFrequencies; + if (!ReadCpuPolicyFrequencies(&cpuPolicyFrequencies)) { + return false; + } + for (const auto &[policyId, cpuFrequencies] : cpuPolicyFrequencies) { + const auto &previousCpuFrequencies = mPreviousCpuPolicyFrequencies.find(policyId); + if (previousCpuFrequencies == mPreviousCpuPolicyFrequencies.end()) { + LOG(ERROR) << "Couldn't find policy " << policyId << " in previous frequencies"; + return false; + } + uint64_t weightedFrequenciesSumHz = 0; + std::chrono::milliseconds timeSum = 0ms; + for (const auto &[frequencyHz, time] : cpuFrequencies) { + const auto &previousCpuFrequency = previousCpuFrequencies->second.find(frequencyHz); + if (previousCpuFrequency == previousCpuFrequencies->second.end()) { + LOG(ERROR) << "Couldn't find frequency " << frequencyHz + << " in previous frequencies"; + return false; + } + const std::chrono::milliseconds recentTime = time - previousCpuFrequency->second; + weightedFrequenciesSumHz += frequencyHz * recentTime.count(); + timeSum += recentTime; + } + const uint64_t averageFrequencyHz = + timeSum != 0ms ? weightedFrequenciesSumHz / timeSum.count() : 0; + result->push_back({.policyId = policyId, .averageFrequencyHz = averageFrequencyHz}); + } + mPreviousCpuPolicyFrequencies = cpuPolicyFrequencies; + return true; +} + +std::map> +CpuFrequencyReader::GetPreviousCpuPolicyFrequencies() const { + return mPreviousCpuPolicyFrequencies; +} + +bool CpuFrequencyReader::ReadCpuPolicyFrequencies( + std::map> *result) { + ATRACE_CALL(); + for (const uint32_t cpuPolicyId : mCpuPolicyIds) { + std::stringstream timeInStatePath; + timeInStatePath << "/sys/devices/system/cpu/cpufreq/policy" << cpuPolicyId + << "/stats/time_in_state"; + std::unique_ptr timeInStateFile; + if (!mFilesystem->ReadFileStream(timeInStatePath.str(), &timeInStateFile)) { + return false; + } + + std::map cpuFrequencies; + std::string timeInStateLine; + while (std::getline(*timeInStateFile, timeInStateLine)) { + // Time format in time_in_state is 10s of milliseconds: + // https://www.kernel.org/doc/Documentation/cpu-freq/cpufreq-stats.txt + uint64_t frequencyHz, time10Ms; + if (std::sscanf(timeInStateLine.c_str(), "%" PRIu64 " %" PRIu64 "\n", &frequencyHz, + &time10Ms) != 2) { + LOG(ERROR) << "Failed to parse time_in_state line: " << timeInStateLine; + return false; + } + cpuFrequencies[frequencyHz] = time10Ms * 10ms; + } + if (cpuFrequencies.size() > 500) { + LOG(ERROR) << "Found " << cpuFrequencies.size() << " frequencies for policy " + << cpuPolicyId << ", aborting"; + return false; + } + (*result)[cpuPolicyId] = cpuFrequencies; + } + return true; +} + +bool CpuFrequencyReader::ReadCpuPolicyIds(std::vector *result) const { + ATRACE_CALL(); + std::vector entries; + if (!mFilesystem->ListDirectory(kCpuPolicyDirectory.data(), &entries)) { + return false; + } + for (const auto &entry : entries) { + uint32_t cpuPolicyId; + if (!sscanf(entry.c_str(), "policy%d", &cpuPolicyId)) { + continue; + } + result->push_back(cpuPolicyId); + } + // Sort the list, so that getRecentCpuPolicyFrequencies always returns frequencies sorted by + // policy ID. + std::sort(result->begin(), result->end()); + return true; +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuFrequencyReader.h b/power-libperfmgr/adaptivecpu/CpuFrequencyReader.h new file mode 100644 index 00000000..ed7a79c9 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/CpuFrequencyReader.h @@ -0,0 +1,91 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#include "IFilesystem.h" +#include "RealFilesystem.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +struct CpuPolicyAverageFrequency { + const uint32_t policyId; + const uint64_t averageFrequencyHz; + + bool operator==(const CpuPolicyAverageFrequency &other) const { + return policyId == other.policyId && averageFrequencyHz == other.averageFrequencyHz; + } +}; + +class CpuFrequencyReader { + public: + CpuFrequencyReader() : mFilesystem(std::make_unique()) {} + CpuFrequencyReader(std::unique_ptr filesystem) + : mFilesystem(std::move(filesystem)) {} + + // Initialize reading, must be done before calling other methods. + // Work is not done in constructor as it accesses files. + // Returns true on success. + bool Init(); + + // Gets the average frequency each CPU policy was using, since this method was last called. + // Results are returned sorted by policyId. + // Returns true on success. + bool GetRecentCpuPolicyFrequencies(std::vector *result); + + // The most recently read frequencies for each CPU policy. See readCpuPolicyFrequencies for type + // explanation. Used for dumping to bug reports. + std::map> + GetPreviousCpuPolicyFrequencies() const; + + private: + // CPU policy IDs read from /sys. Initialized in #init(). Sorted ascending. + std::vector mCpuPolicyIds; + // The CPU frequencies when #getRecentCpuPolicyFrequencies was last called (or #init if it has + // not been called yet). + // See readCpuPolicyFrequencies for explanation of type. + std::map> mPreviousCpuPolicyFrequencies; + const std::unique_ptr mFilesystem; + + // Reads, from the /sys filesystem, the CPU frequencies used by each policy. + // - The outer map's key is the CPU policy ID. + // - The inner map's key is the CPU frequency in Hz. + // - The inner map's value is the time the policy has been running at that frequency, aggregated + // since boot. + // Returns true on success. + bool ReadCpuPolicyFrequencies( + std::map> *result); + + bool ReadCpuPolicyIds(std::vector *result) const; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.cpp b/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.cpp new file mode 100644 index 00000000..f91028b9 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.cpp @@ -0,0 +1,132 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "CpuLoadReaderProcStat.h" + +#include +#include +#include + +#include +#include +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +bool CpuLoadReaderProcStat::Init() { + mPreviousCpuTimes.clear(); + return ReadCpuTimes(&mPreviousCpuTimes); +} + +bool CpuLoadReaderProcStat::GetRecentCpuLoads( + std::array *cpuCoreIdleTimesPercentage) { + ATRACE_CALL(); + if (cpuCoreIdleTimesPercentage == nullptr) { + LOG(ERROR) << "Got nullptr output in getRecentCpuLoads"; + return false; + } + std::map cpuTimes; + if (!ReadCpuTimes(&cpuTimes)) { + return false; + } + if (cpuTimes.empty()) { + LOG(ERROR) << "Failed to find any CPU times"; + return false; + } + for (const auto &[cpuId, cpuTime] : cpuTimes) { + const auto previousCpuTime = mPreviousCpuTimes.find(cpuId); + if (previousCpuTime == mPreviousCpuTimes.end()) { + LOG(ERROR) << "Couldn't find CPU " << cpuId << " in previous CPU times"; + return false; + } + const auto recentIdleTimeMs = cpuTime.idleTimeMs - previousCpuTime->second.idleTimeMs; + const auto recentTotalTimeMs = cpuTime.totalTimeMs - previousCpuTime->second.totalTimeMs; + if (recentIdleTimeMs > recentTotalTimeMs) { + LOG(ERROR) << "Found more recent idle time than total time: idle=" << recentIdleTimeMs + << ", total=" << recentTotalTimeMs; + return false; + } + const double idleTimePercentage = + static_cast(recentIdleTimeMs) / (recentTotalTimeMs); + LOG(VERBOSE) << "Read CPU idle time: cpuId=" << cpuId + << ", idleTimePercentage=" << idleTimePercentage; + (*cpuCoreIdleTimesPercentage)[cpuId] = idleTimePercentage; + } + mPreviousCpuTimes = cpuTimes; + return true; +} + +bool CpuLoadReaderProcStat::ReadCpuTimes(std::map *result) { + ATRACE_CALL(); + + std::unique_ptr file; + if (!mFilesystem->ReadFileStream("/proc/stat", &file)) { + return false; + } + std::string line; + ATRACE_BEGIN("loop"); + while (std::getline(*file, line)) { + ATRACE_NAME("parse"); + uint32_t cpuId; + // Times reported when the CPU is active. + uint64_t user, nice, system, irq, softIrq, steal, guest, guestNice; + // Times reported when the CPU is idle. + uint64_t idle, ioWait; + // Order & values taken from `fs/proc/stat.c`. + if (std::sscanf(line.c_str(), + "cpu%d %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 + " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " ", + &cpuId, &user, &nice, &system, &idle, &ioWait, &irq, &softIrq, &steal, + &guest, &guestNice) != 11) { + continue; + } + uint64_t idleTimeJiffies = idle + ioWait; + uint64_t totalTimeJiffies = + user + nice + system + irq + softIrq + steal + guest + guestNice + idleTimeJiffies; + (*result)[cpuId] = {.idleTimeMs = JiffiesToMs(idleTimeJiffies), + .totalTimeMs = JiffiesToMs(totalTimeJiffies)}; + } + ATRACE_END(); + return true; +} + +void CpuLoadReaderProcStat::DumpToStream(std::stringstream &stream) const { + stream << "CPU loads from /proc/stat:\n"; + for (const auto &[cpuId, cpuTime] : mPreviousCpuTimes) { + stream << "- CPU=" << cpuId << ", idleTime=" << cpuTime.idleTimeMs + << "ms, totalTime=" << cpuTime.totalTimeMs << "ms\n"; + } +} + +uint64_t CpuLoadReaderProcStat::JiffiesToMs(uint64_t jiffies) { + return (jiffies * 1000) / sysconf(_SC_CLK_TCK); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.h b/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.h new file mode 100644 index 00000000..81eb3a84 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.h @@ -0,0 +1,63 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "ICpuLoadReader.h" +#include "IFilesystem.h" +#include "RealFilesystem.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +struct CpuTime { + uint64_t idleTimeMs; + uint64_t totalTimeMs; +}; + +// Reads CPU idle stats from /proc/stat. +class CpuLoadReaderProcStat : public ICpuLoadReader { + public: + CpuLoadReaderProcStat() : mFilesystem(std::make_unique()) {} + CpuLoadReaderProcStat(std::unique_ptr filesystem) + : mFilesystem(std::move(filesystem)) {} + + bool Init() override; + bool GetRecentCpuLoads(std::array *cpuCoreIdleTimesPercentage) override; + void DumpToStream(std::stringstream &stream) const override; + + private: + std::map mPreviousCpuTimes; + const std::unique_ptr mFilesystem; + + bool ReadCpuTimes(std::map *result); + // Converts jiffies to milliseconds. Jiffies is the granularity the kernel reports times in, + // including the timings in CPU statistics. + static uint64_t JiffiesToMs(uint64_t jiffies); +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.cpp b/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.cpp new file mode 100644 index 00000000..6107997e --- /dev/null +++ b/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.cpp @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "CpuLoadReaderSysDevices.h" + +#include +#include +#include + +#include +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +std::chrono::nanoseconds getKernelTime() { + timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return std::chrono::nanoseconds(ts.tv_sec * 1000000000UL + ts.tv_nsec); +} + +bool CpuLoadReaderSysDevices::Init() { + mIdleStateNames.clear(); + if (!ReadIdleStateNames(&mIdleStateNames)) { + return false; + } + return ReadCpuTimes(&mPreviousCpuTimes); +} + +bool CpuLoadReaderSysDevices::GetRecentCpuLoads( + std::array *cpuCoreIdleTimesPercentage) { + ATRACE_CALL(); + if (cpuCoreIdleTimesPercentage == nullptr) { + LOG(ERROR) << "Got nullptr output in getRecentCpuLoads"; + return false; + } + std::array cpuTimes; + if (!ReadCpuTimes(&cpuTimes)) { + return false; + } + if (cpuTimes.empty()) { + LOG(ERROR) << "Failed to find any CPU times"; + return false; + } + for (size_t cpuId = 0; cpuId < NUM_CPU_CORES; cpuId++) { + const auto cpuTime = cpuTimes[cpuId]; + const auto previousCpuTime = mPreviousCpuTimes[cpuId]; + auto recentIdleTime = cpuTime.idleTime - previousCpuTime.idleTime; + const auto recentTotalTime = cpuTime.totalTime - previousCpuTime.totalTime; + if (recentIdleTime > recentTotalTime) { + // This happens occasionally, as we use the idle time from the kernel, and the current + // time from userspace. + recentIdleTime = recentTotalTime; + } + const double idleTimePercentage = + static_cast(recentIdleTime.count()) / recentTotalTime.count(); + (*cpuCoreIdleTimesPercentage)[cpuId] = idleTimePercentage; + } + mPreviousCpuTimes = cpuTimes; + return true; +} + +void CpuLoadReaderSysDevices::DumpToStream(std::stringstream &stream) const { + stream << "CPU loads from /sys/devices/system/cpu/cpuN/cpuidle:\n"; + for (size_t cpuId = 0; cpuId < NUM_CPU_CORES; cpuId++) { + stream << "- CPU=" << cpuId << ", idleTime=" << mPreviousCpuTimes[cpuId].idleTime.count() + << "ms, totalTime=" << mPreviousCpuTimes[cpuId].totalTime.count() << "ms\n"; + } +} + +bool CpuLoadReaderSysDevices::ReadCpuTimes(std::array *result) const { + ATRACE_CALL(); + const auto totalTime = mTimeSource->GetTime(); + + for (size_t cpuId = 0; cpuId < NUM_CPU_CORES; cpuId++) { + std::chrono::microseconds idleTime; + for (const auto &idleStateName : mIdleStateNames) { + std::stringstream cpuIdlePath; + cpuIdlePath << "/sys/devices/system/cpu/" + << "cpu" << cpuId << "/cpuidle/" << idleStateName << "/time"; + std::unique_ptr file; + if (!mFilesystem->ReadFileStream(cpuIdlePath.str(), &file)) { + return false; + } + // Times are reported in microseconds: + // https://www.kernel.org/doc/Documentation/cpuidle/sysfs.txt + std::string idleTimeUs(std::istreambuf_iterator(*file), {}); + idleTime += std::chrono::microseconds(std::atoi(idleTimeUs.c_str())); + } + (*result)[cpuId] = { + .idleTime = idleTime, + .totalTime = std::chrono::duration_cast(totalTime), + }; + } + + return true; +} + +bool CpuLoadReaderSysDevices::ReadIdleStateNames(std::vector *result) const { + std::vector idleStateNames; + if (!mFilesystem->ListDirectory("/sys/devices/system/cpu/cpu0/cpuidle", &idleStateNames)) { + return false; + } + for (const auto &idleStateName : idleStateNames) { + if (idleStateName.length() == 0 || idleStateName[0] == '.') { + continue; + } + std::vector files; + if (!mFilesystem->ListDirectory( + std::string("/sys/devices/system/cpu/cpu0/cpuidle/") + idleStateName, &files)) { + return false; + } + if (std::find(files.begin(), files.end(), "time") == files.end()) { + continue; + } + result->push_back(idleStateName); + } + if (idleStateNames.empty()) { + LOG(ERROR) << "Found no idle state names"; + return false; + } + return true; +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.h b/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.h new file mode 100644 index 00000000..f5022ce0 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.h @@ -0,0 +1,71 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "ICpuLoadReader.h" +#include "IFilesystem.h" +#include "ITimeSource.h" +#include "Model.h" +#include "RealFilesystem.h" +#include "TimeSource.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +struct CpuTime { + std::chrono::microseconds idleTime; + std::chrono::microseconds totalTime; +}; + +// Reads CPU idle stats from /sys/devices/system/cpu/cpuN/cpuidle. +class CpuLoadReaderSysDevices : public ICpuLoadReader { + public: + CpuLoadReaderSysDevices() + : mFilesystem(std::make_unique()), + mTimeSource(std::make_unique()) {} + CpuLoadReaderSysDevices(std::unique_ptr filesystem, + std::unique_ptr timeSource) + : mFilesystem(std::move(filesystem)), mTimeSource(std::move(timeSource)) {} + + bool Init() override; + bool GetRecentCpuLoads(std::array *cpuCoreIdleTimesPercentage) override; + void DumpToStream(std::stringstream &stream) const override; + + private: + const std::unique_ptr mFilesystem; + const std::unique_ptr mTimeSource; + + std::array mPreviousCpuTimes; + std::vector mIdleStateNames; + + bool ReadCpuTimes(std::array *result) const; + bool ReadIdleStateNames(std::vector *result) const; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/Device.cpp b/power-libperfmgr/adaptivecpu/Device.cpp new file mode 100644 index 00000000..54366fbd --- /dev/null +++ b/power-libperfmgr/adaptivecpu/Device.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-libperfmgr" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "Device.h" + +#include +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +Device ReadDevice() { + ATRACE_CALL(); + const std::string deviceProperty = ::android::base::GetProperty("ro.product.device", ""); + Device device; + if (deviceProperty == "raven") { + device = Device::RAVEN; + } else if (deviceProperty == "oriole") { + device = Device::ORIOLE; + } else { + LOG(WARNING) << "Failed to parse device property, setting to UNKNOWN: " << deviceProperty; + device = Device::UNKNOWN; + } + LOG(DEBUG) << "Parsed device: deviceProperty=" << deviceProperty + << ", device=" << static_cast(device); + return device; +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/Device.h b/power-libperfmgr/adaptivecpu/Device.h new file mode 100644 index 00000000..8e357a31 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/Device.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +enum class Device { UNKNOWN = 0, RAVEN = 1, ORIOLE = 2 }; + +Device ReadDevice(); + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/ICpuLoadReader.h b/power-libperfmgr/adaptivecpu/ICpuLoadReader.h new file mode 100644 index 00000000..62321f75 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/ICpuLoadReader.h @@ -0,0 +1,49 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "Model.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +class ICpuLoadReader { + public: + // Initialize reading, must be done before calling other methods. + // Work is not done in constructor as it accesses files. + virtual bool Init() = 0; + // Get the load of each CPU, since the last time this method was called. + virtual bool GetRecentCpuLoads( + std::array *cpuCoreIdleTimesPercentage) = 0; + // Dump internal state to a string stream. Used for dumpsys. + virtual void DumpToStream(std::stringstream &stream) const = 0; + virtual ~ICpuLoadReader() {} +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/IFilesystem.h b/power-libperfmgr/adaptivecpu/IFilesystem.h new file mode 100644 index 00000000..2ec7ad1d --- /dev/null +++ b/power-libperfmgr/adaptivecpu/IFilesystem.h @@ -0,0 +1,49 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +// Abstracted so we can mock in tests. +class IFilesystem { + public: + virtual ~IFilesystem() {} + virtual bool ListDirectory(const std::string &path, std::vector *result) const = 0; + virtual bool ReadFileStream(const std::string &path, + std::unique_ptr *result) const = 0; + // Resets the file stream, so that the next read will read from the beginning. + // This function exists in IFilesystem rather than using istream::seekg directly. This is + // so we can mock this function in tests, allowing us to return different data on reset. + virtual bool ResetFileStream(const std::unique_ptr &fileStream) const = 0; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/ITimeSource.h b/power-libperfmgr/adaptivecpu/ITimeSource.h new file mode 100644 index 00000000..f2805934 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/ITimeSource.h @@ -0,0 +1,41 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +// Abstracted so we can mock in tests. +class ITimeSource { + public: + virtual ~ITimeSource() {} + virtual std::chrono::nanoseconds GetTime() const = 0; + virtual std::chrono::nanoseconds GetKernelTime() const = 0; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.cpp b/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.cpp new file mode 100644 index 00000000..087f03d9 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.cpp @@ -0,0 +1,135 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "KernelCpuFeatureReader.h" + +#include +#include + +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +constexpr std::string_view kKernelFilePath("/proc/vendor_sched/acpu_stats"); +constexpr size_t kReadBufferSize = sizeof(acpu_stats) * NUM_CPU_CORES; + +bool KernelCpuFeatureReader::Init() { + ATRACE_CALL(); + if (!OpenStatsFile(&mStatsFile)) { + return false; + } + return ReadStats(&mPreviousStats, &mPreviousReadTime); +} + +bool KernelCpuFeatureReader::GetRecentCpuFeatures( + std::array *cpuPolicyAverageFrequencyHz, + std::array *cpuCoreIdleTimesPercentage) { + ATRACE_CALL(); + std::array stats; + std::chrono::nanoseconds readTime; + if (!ReadStats(&stats, &readTime)) { + return false; + } + const std::chrono::nanoseconds timeDelta = readTime - mPreviousReadTime; + + for (size_t i = 0; i < NUM_CPU_POLICIES; i++) { + // acpu_stats has data per-CPU, but frequency data is equivalent for all CPUs in a policy. + // So, we only read the first CPU in each policy. + const size_t statsIdx = CPU_POLICY_INDICES[i]; + if (stats[statsIdx].weighted_sum_freq < mPreviousStats[statsIdx].weighted_sum_freq) { + LOG(WARNING) << "New weighted_sum_freq is less than old: new=" + << stats[statsIdx].weighted_sum_freq + << ", old=" << mPreviousStats[statsIdx].weighted_sum_freq; + mPreviousStats[statsIdx].weighted_sum_freq = stats[statsIdx].weighted_sum_freq; + } + (*cpuPolicyAverageFrequencyHz)[i] = + static_cast(stats[statsIdx].weighted_sum_freq - + mPreviousStats[statsIdx].weighted_sum_freq) / + timeDelta.count(); + } + for (size_t i = 0; i < NUM_CPU_CORES; i++) { + if (stats[i].total_idle_time_ns < mPreviousStats[i].total_idle_time_ns) { + LOG(WARNING) << "New total_idle_time_ns is less than old: new=" + << stats[i].total_idle_time_ns + << ", old=" << mPreviousStats[i].total_idle_time_ns; + mPreviousStats[i].total_idle_time_ns = stats[i].total_idle_time_ns; + } + (*cpuCoreIdleTimesPercentage)[i] = + static_cast(stats[i].total_idle_time_ns - + mPreviousStats[i].total_idle_time_ns) / + timeDelta.count(); + } + + mPreviousStats = stats; + mPreviousReadTime = readTime; + return true; +} + +bool KernelCpuFeatureReader::OpenStatsFile(std::unique_ptr *file) { + ATRACE_CALL(); + return mFilesystem->ReadFileStream(kKernelFilePath.data(), file); +} + +bool KernelCpuFeatureReader::ReadStats(std::array *stats, + std::chrono::nanoseconds *readTime) { + ATRACE_CALL(); + *readTime = mTimeSource->GetKernelTime(); + if (!mFilesystem->ResetFileStream(mStatsFile)) { + return false; + } + char buffer[kReadBufferSize]; + { + ATRACE_NAME("read"); + if (!mStatsFile->read(buffer, kReadBufferSize).good()) { + LOG(ERROR) << "Failed to read stats file"; + return false; + } + } + const size_t bytesRead = mStatsFile->gcount(); + if (bytesRead != kReadBufferSize) { + LOG(ERROR) << "Didn't read full data: expected=" << kReadBufferSize + << ", actual=" << bytesRead; + return false; + } + const auto kernelStructs = reinterpret_cast(buffer); + std::copy(kernelStructs, kernelStructs + NUM_CPU_CORES, stats->begin()); + return true; +} + +void KernelCpuFeatureReader::DumpToStream(std::ostream &stream) const { + ATRACE_CALL(); + stream << "CPU features from acpu_stats:\n"; + for (size_t i = 0; i < NUM_CPU_CORES; i++) { + stream << "- CPU " << i << ": weighted_sum_freq=" << mPreviousStats[i].weighted_sum_freq + << ", total_idle_time_ns=" << mPreviousStats[i].total_idle_time_ns << "\n"; + } + stream << "- Last read time: " << mPreviousReadTime.count() << "ns\n"; +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.h b/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.h new file mode 100644 index 00000000..bd9e319a --- /dev/null +++ b/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.h @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +#include "IFilesystem.h" +#include "ITimeSource.h" +#include "Model.h" +#include "RealFilesystem.h" +#include "TimeSource.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +// Kernel <-> Userspace ABI for CPU features. See kernel/sched/acpu.c. +// Contains CPU statistics for a single CPU. The kernel reports an `acpu_stats` struct for each CPU +// on the system. +struct acpu_stats { + // Sum of the CPU frequencies that the CPU used, multiplied by how much time was spent in each + // frequency. Measured in ns*KHz. E.g.: + // 10ns at 100MHz, 2ns at 50MHz = 10*100,000 + 2*50,000 = 1,100,000 + // This is used to calculate the average frequency the CPU was running at between two times: + // (new.weighted_sum_freq - old.weighted_sum_freq) / elapsed_time_ns + uint64_t weighted_sum_freq; + // The total time (in nanoseconds) that the CPU was idle. + // This is ued to calculate the percent of time the CPU was idle between two times: + // (new.total_idle_time_ns - old.total_idle_time_ns) / elapsed_time_ns + uint64_t total_idle_time_ns; +}; + +class KernelCpuFeatureReader { + public: + KernelCpuFeatureReader() + : mFilesystem(std::make_unique()), + mTimeSource(std::make_unique()) {} + KernelCpuFeatureReader(std::unique_ptr filesystem, + std::unique_ptr timeSource) + : mFilesystem(std::move(filesystem)), mTimeSource(std::move(timeSource)) {} + + bool Init(); + bool GetRecentCpuFeatures(std::array *cpuPolicyAverageFrequencyHz, + std::array *cpuCoreIdleTimesPercentage); + void DumpToStream(std::ostream &stream) const; + + private: + const std::unique_ptr mFilesystem; + const std::unique_ptr mTimeSource; + // We only open the stats file once and reuse the file descriptor. We find this reduces + // ReadStats runtime by 2x. + std::unique_ptr mStatsFile; + std::array mPreviousStats; + std::chrono::nanoseconds mPreviousReadTime; + bool OpenStatsFile(std::unique_ptr *file); + bool ReadStats(std::array *stats, + std::chrono::nanoseconds *readTime); +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/Model.cpp b/power-libperfmgr/adaptivecpu/Model.cpp new file mode 100644 index 00000000..ca85d158 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/Model.cpp @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "Model.h" + +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +bool ModelInput::SetCpuFreqiencies( + const std::vector &cpuPolicyAverageFrequencies) { + ATRACE_CALL(); + if (cpuPolicyAverageFrequencies.size() != cpuPolicyAverageFrequencyHz.size()) { + LOG(ERROR) << "Received incorrect amount of CPU policy frequencies, expected " + << cpuPolicyAverageFrequencyHz.size() << ", received " + << cpuPolicyAverageFrequencies.size(); + return false; + } + int32_t previousPolicyId = -1; + for (uint32_t i = 0; i < cpuPolicyAverageFrequencies.size(); i++) { + if (previousPolicyId >= static_cast(cpuPolicyAverageFrequencies[i].policyId)) { + LOG(ERROR) << "CPU frequencies weren't sorted by policy ID, found " << previousPolicyId + << " " << cpuPolicyAverageFrequencies[i].policyId; + return false; + } + previousPolicyId = cpuPolicyAverageFrequencies[i].policyId; + cpuPolicyAverageFrequencyHz[i] = cpuPolicyAverageFrequencies[i].averageFrequencyHz; + } + return true; +} + +void ModelInput::LogToAtrace() const { + if (!ATRACE_ENABLED()) { + return; + } + ATRACE_CALL(); + for (int i = 0; i < cpuPolicyAverageFrequencyHz.size(); i++) { + ATRACE_INT((std::string("ModelInput_frequency_") + std::to_string(i)).c_str(), + static_cast(cpuPolicyAverageFrequencyHz[i])); + } + for (int i = 0; i < cpuCoreIdleTimesPercentage.size(); i++) { + ATRACE_INT((std::string("ModelInput_idle_") + std::to_string(i)).c_str(), + static_cast(cpuCoreIdleTimesPercentage[i] * 100)); + } + ATRACE_INT("ModelInput_workDurations_averageDurationNs", + workDurationFeatures.averageDuration.count()); + ATRACE_INT("ModelInput_workDurations_maxDurationNs", workDurationFeatures.maxDuration.count()); + ATRACE_INT("ModelInput_workDurations_numMissedDeadlines", + workDurationFeatures.numMissedDeadlines); + ATRACE_INT("ModelInput_workDurations_numDurations", workDurationFeatures.numDurations); + ATRACE_INT("ModelInput_prevThrottle", (int)previousThrottleDecision); + ATRACE_INT("ModelInput_device", static_cast(device)); +} + +ThrottleDecision Model::Run(const std::deque &modelInputs, + const AdaptiveCpuConfig &config) { + ATRACE_CALL(); + if (config.randomThrottleDecisionProbability > 0 && + mShouldRandomThrottleDistribution(mGenerator) < config.randomThrottleDecisionProbability) { + std::uniform_int_distribution optionDistribution( + 0, config.randomThrottleOptions.size() - 1); + const ThrottleDecision throttleDecision = + config.randomThrottleOptions[optionDistribution(mGenerator)]; + LOG(VERBOSE) << "Randomly overrided throttle decision: " + << static_cast(throttleDecision); + ATRACE_INT("AdaptiveCpu_randomThrottleDecision", static_cast(throttleDecision)); + return throttleDecision; + } + ATRACE_INT("AdaptiveCpu_randomThrottleDecision", -1); + return RunDecisionTree(modelInputs); +} + +ThrottleDecision Model::RunDecisionTree(const std::deque &modelInputs + __attribute__((unused))) { + ATRACE_CALL(); +#include "models/model.inc" +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/Model.h b/power-libperfmgr/adaptivecpu/Model.h new file mode 100644 index 00000000..2a00a8f9 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/Model.h @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +#include +#include +#include +#include +#include + +#include "AdaptiveCpuConfig.h" +#include "CpuFrequencyReader.h" +#include "Device.h" +#include "ThrottleDecision.h" +#include "WorkDurationProcessor.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +// Currently Adaptive CPU is targeted to only raven/oriole, so we can hardcode the CPU architecture. +// If we extend to other architectures, this will have to vary per-device or be dynamically loaded. +constexpr uint32_t NUM_CPU_CORES = 8; +constexpr uint32_t NUM_CPU_POLICIES = 3; +constexpr std::array CPU_POLICY_INDICES{0, 4, 6}; + +struct ModelInput { + std::array cpuPolicyAverageFrequencyHz; + std::array cpuCoreIdleTimesPercentage; + WorkDurationFeatures workDurationFeatures; + ThrottleDecision previousThrottleDecision; + Device device; + + bool SetCpuFreqiencies( + const std::vector &cpuPolicyAverageFrequencies); + + void LogToAtrace() const; + + bool operator==(const ModelInput &other) const { + return cpuPolicyAverageFrequencyHz == other.cpuPolicyAverageFrequencyHz && + cpuCoreIdleTimesPercentage == other.cpuCoreIdleTimesPercentage && + workDurationFeatures == other.workDurationFeatures && + previousThrottleDecision == other.previousThrottleDecision; + } +}; + +class Model { + public: + Model() + : mShouldRandomThrottleDistribution(0, 1), + mRandomThrottleDistribution(static_cast(ThrottleDecision::FIRST), + static_cast(ThrottleDecision::LAST)) {} + ThrottleDecision Run(const std::deque &modelInputs, + const AdaptiveCpuConfig &config); + + private: + std::default_random_engine mGenerator; + std::uniform_real_distribution mShouldRandomThrottleDistribution; + std::uniform_int_distribution mRandomThrottleDistribution; + + ThrottleDecision RunDecisionTree(const std::deque &modelInputs); +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/RealFilesystem.cpp b/power-libperfmgr/adaptivecpu/RealFilesystem.cpp new file mode 100644 index 00000000..b84796b0 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/RealFilesystem.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "RealFilesystem.h" + +#include +#include +#include + +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +bool RealFilesystem::ListDirectory(const std::string &path, + std::vector *result) const { + ATRACE_CALL(); + // We can't use std::filesystem, see aosp/894015 & b/175635923. + auto dir = std::unique_ptr{opendir(path.c_str()), closedir}; + if (!dir) { + LOG(ERROR) << "Failed to open directory " << path; + return false; + } + dirent *entry; + while ((entry = readdir(&*dir)) != nullptr) { + result->emplace_back(entry->d_name); + } + return true; +} + +bool RealFilesystem::ReadFileStream(const std::string &path, + std::unique_ptr *result) const { + ATRACE_CALL(); + *result = std::make_unique(path); + if ((*result)->fail()) { + LOG(ERROR) << "Failed to read file stream: " << path; + return false; + } + return true; +} + +bool RealFilesystem::ResetFileStream(const std::unique_ptr &fileStream) const { + if (fileStream->seekg(0).bad()) { + LOG(ERROR) << "Failed to reset file stream"; + return false; + } + return true; +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/RealFilesystem.h b/power-libperfmgr/adaptivecpu/RealFilesystem.h new file mode 100644 index 00000000..1a877dbd --- /dev/null +++ b/power-libperfmgr/adaptivecpu/RealFilesystem.h @@ -0,0 +1,46 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#include "IFilesystem.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +class RealFilesystem : public IFilesystem { + public: + virtual ~RealFilesystem() {} + bool ListDirectory(const std::string &path, std::vector *result) const override; + bool ReadFileStream(const std::string &path, + std::unique_ptr *result) const override; + bool ResetFileStream(const std::unique_ptr &fileStream) const override; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/ThrottleDecision.cpp b/power-libperfmgr/adaptivecpu/ThrottleDecision.cpp new file mode 100644 index 00000000..31d19e82 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/ThrottleDecision.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ThrottleDecision.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +std::string ThrottleString(ThrottleDecision throttleDecision) { + switch (throttleDecision) { + case ThrottleDecision::NO_THROTTLE: + return "NO_THROTTLE"; + case ThrottleDecision::THROTTLE_60: + return "THROTTLE_60"; + case ThrottleDecision::THROTTLE_70: + return "THROTTLE_70"; + case ThrottleDecision::THROTTLE_80: + return "THROTTLE_80"; + case ThrottleDecision::THROTTLE_90: + return "THROTTLE_90"; + default: + return "unknown"; + } +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/ThrottleDecision.h b/power-libperfmgr/adaptivecpu/ThrottleDecision.h new file mode 100644 index 00000000..8a95c968 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/ThrottleDecision.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +enum class ThrottleDecision { + NO_THROTTLE = 0, + THROTTLE_50 = 1, + THROTTLE_60 = 2, + THROTTLE_70 = 3, + THROTTLE_80 = 4, + THROTTLE_90 = 5, + FIRST = NO_THROTTLE, + LAST = THROTTLE_90, +}; + +std::string ThrottleString(ThrottleDecision throttleDecision); + +static const std::unordered_map> + THROTTLE_DECISION_TO_HINT_NAMES = { + {ThrottleDecision::NO_THROTTLE, {}}, + {ThrottleDecision::THROTTLE_50, + {"LOW_POWER_LITTLE_CLUSTER_50", "LOW_POWER_MID_CLUSTER_50", "LOW_POWER_CPU_50"}}, + {ThrottleDecision::THROTTLE_60, + {"LOW_POWER_LITTLE_CLUSTER_60", "LOW_POWER_MID_CLUSTER_60", "LOW_POWER_CPU_60"}}, + {ThrottleDecision::THROTTLE_70, + {"LOW_POWER_LITTLE_CLUSTER_70", "LOW_POWER_MID_CLUSTER_70", "LOW_POWER_CPU_70"}}, + {ThrottleDecision::THROTTLE_80, + {"LOW_POWER_LITTLE_CLUSTER_80", "LOW_POWER_MID_CLUSTER_80", "LOW_POWER_CPU_80"}}, + {ThrottleDecision::THROTTLE_90, + {"LOW_POWER_LITTLE_CLUSTER_90", "LOW_POWER_MID_CLUSTER_90", "LOW_POWER_CPU_90"}}}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/TimeSource.cpp b/power-libperfmgr/adaptivecpu/TimeSource.cpp new file mode 100644 index 00000000..5191c354 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/TimeSource.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "TimeSource.h" + +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +std::chrono::nanoseconds TimeSource::GetTime() const { + ATRACE_CALL(); + return std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()); +} + +std::chrono::nanoseconds TimeSource::GetKernelTime() const { + ATRACE_CALL(); + timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return std::chrono::nanoseconds(ts.tv_sec * 1000000000UL + ts.tv_nsec); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/TimeSource.h b/power-libperfmgr/adaptivecpu/TimeSource.h new file mode 100644 index 00000000..d173cfe1 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/TimeSource.h @@ -0,0 +1,40 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ITimeSource.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +class TimeSource : public ITimeSource { + public: + ~TimeSource() override {} + std::chrono::nanoseconds GetTime() const override; + std::chrono::nanoseconds GetKernelTime() const override; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/WorkDurationProcessor.cpp b/power-libperfmgr/adaptivecpu/WorkDurationProcessor.cpp new file mode 100644 index 00000000..81d026e3 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/WorkDurationProcessor.cpp @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-adaptivecpu" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "WorkDurationProcessor.h" + +#include +#include + +using std::chrono_literals::operator""ms; +using std::chrono_literals::operator""ns; + +// The standard target duration, based on 60 FPS. Durations submitted with different targets are +// normalized against this target. For example, a duration that was at 80% of its target will be +// scaled to 0.8 * kNormalTargetDuration. +constexpr std::chrono::nanoseconds kNormalTargetDuration = 16666666ns; + +// All durations shorter than this are ignored. +constexpr std::chrono::nanoseconds kMinDuration = 0ns; + +// All durations longer than this are ignored. +constexpr std::chrono::nanoseconds kMaxDuration = 600 * kNormalTargetDuration; + +// If we haven't processed a lot of batches, stop accepting new ones. In cases where the processing +// thread has crashed, but the reporting thread is still reporting, this prevents consuming large +// amounts of memory. +// TODO(b/213160386): Move to AdaptiveCpuConfig. +constexpr size_t kMaxUnprocessedBatches = 1000; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +bool WorkDurationProcessor::ReportWorkDurations(const std::vector &workDurations, + std::chrono::nanoseconds targetDuration) { + ATRACE_CALL(); + LOG(VERBOSE) << "Received " << workDurations.size() << " work durations with target " + << targetDuration.count() << "ns"; + std::unique_lock lock(mMutex); + if (mWorkDurationBatches.size() >= kMaxUnprocessedBatches) { + LOG(ERROR) << "Adaptive CPU isn't processing work durations fast enough"; + mWorkDurationBatches.clear(); + return false; + } + mWorkDurationBatches.emplace_back(workDurations, targetDuration); + return true; +} + +WorkDurationFeatures WorkDurationProcessor::GetFeatures() { + ATRACE_CALL(); + + std::vector workDurationBatches; + { + ATRACE_NAME("lock"); + std::unique_lock lock(mMutex); + mWorkDurationBatches.swap(workDurationBatches); + } + + std::chrono::nanoseconds durationsSum = 0ns; + std::chrono::nanoseconds maxDuration = 0ns; + uint32_t numMissedDeadlines = 0; + uint32_t numDurations = 0; + for (const WorkDurationBatch &batch : workDurationBatches) { + for (const WorkDuration workDuration : batch.workDurations) { + std::chrono::nanoseconds duration(workDuration.durationNanos); + if (duration < kMinDuration || duration > kMaxDuration) { + continue; + } + + // Normalise the duration and add it to the total. + // kMaxDuration * kStandardTarget.count() fits comfortably within int64_t. + std::chrono::nanoseconds durationNormalized = + (duration * kNormalTargetDuration.count()) / batch.targetDuration.count(); + durationsSum += durationNormalized; + maxDuration = std::max(maxDuration, durationNormalized); + if (duration > batch.targetDuration) { + ++numMissedDeadlines; + } + ++numDurations; + } + } + + std::chrono::nanoseconds averageDuration = durationsSum / numDurations; + return { + .averageDuration = averageDuration, + .maxDuration = maxDuration, + .numMissedDeadlines = numMissedDeadlines, + .numDurations = numDurations, + }; +} + +bool WorkDurationProcessor::HasWorkDurations() { + std::unique_lock lock(mMutex); + return !mWorkDurationBatches.empty(); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/WorkDurationProcessor.h b/power-libperfmgr/adaptivecpu/WorkDurationProcessor.h new file mode 100644 index 00000000..eb7f3e29 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/WorkDurationProcessor.h @@ -0,0 +1,76 @@ +#pragma once + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using ::aidl::android::hardware::power::WorkDuration; + +struct WorkDurationBatch { + WorkDurationBatch(const std::vector &workDurations, + std::chrono::nanoseconds targetDuration) + : workDurations(workDurations), targetDuration(targetDuration) {} + const std::vector workDurations; + const std::chrono::nanoseconds targetDuration; +}; + +struct WorkDurationFeatures { + std::chrono::nanoseconds averageDuration; + std::chrono::nanoseconds maxDuration; + uint32_t numMissedDeadlines; + uint32_t numDurations; + + bool operator==(const WorkDurationFeatures &other) const { + return averageDuration == other.averageDuration && maxDuration == other.maxDuration && + numMissedDeadlines == other.numMissedDeadlines && numDurations == other.numDurations; + } +}; + +class WorkDurationProcessor { + public: + bool ReportWorkDurations(const std::vector &workDurations, + std::chrono::nanoseconds targetDuration); + + WorkDurationFeatures GetFeatures(); + + // True if ReportWorkDurations has been called since GetFeatures was last called. + bool HasWorkDurations(); + + private: + // The work durations reported since GetFeatures() was last called. + // Ordered from least recent to most recent. + std::vector mWorkDurationBatches; + // Guards reading/writing mWorkDurationBatches. + std::mutex mMutex; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/models/CPPLINT.cfg b/power-libperfmgr/adaptivecpu/models/CPPLINT.cfg new file mode 100644 index 00000000..3c93947a --- /dev/null +++ b/power-libperfmgr/adaptivecpu/models/CPPLINT.cfg @@ -0,0 +1 @@ +exclude_files=.* \ No newline at end of file diff --git a/power-libperfmgr/adaptivecpu/models/OWNERS b/power-libperfmgr/adaptivecpu/models/OWNERS new file mode 100644 index 00000000..1f4ba7a0 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/models/OWNERS @@ -0,0 +1,4 @@ +benm@google.com +miloslav@google.com +mishaw@google.com +silviavinyes@google.com \ No newline at end of file diff --git a/power-libperfmgr/adaptivecpu/models/model.inc b/power-libperfmgr/adaptivecpu/models/model.inc new file mode 100644 index 00000000..535d60b2 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/models/model.inc @@ -0,0 +1,180030 @@ + + + double cpuPolicyAverageFrequencyHz_0_2 = (((double)modelInputs[2].cpuPolicyAverageFrequencyHz[0]*1.0)-1055037.625)/(511727.688); + + double cpuPolicyAverageFrequencyHz_1_2 = (((double)modelInputs[2].cpuPolicyAverageFrequencyHz[1]*1.0)-712505.312)/(336328.062); + + double cpuPolicyAverageFrequencyHz_2_2 = (((double)modelInputs[2].cpuPolicyAverageFrequencyHz[2]*1.0)-730408.0)/(307773.469); + + double cpuCoreIdleTimesPercentage_0_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[0]*100.0)-75.439)/(23.187); + + double cpuCoreIdleTimesPercentage_1_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[1]*100.0)-78.271)/(22.72); + + double cpuCoreIdleTimesPercentage_2_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[2]*100.0)-76.271)/(24.635); + + double cpuCoreIdleTimesPercentage_3_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[3]*100.0)-75.237)/(24.816); + + double cpuCoreIdleTimesPercentage_4_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[4]*100.0)-79.83)/(15.229); + + double cpuCoreIdleTimesPercentage_5_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[5]*100.0)-80.216)/(15.143); + + double cpuCoreIdleTimesPercentage_6_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[6]*100.0)-78.238)/(11.86); + + double cpuCoreIdleTimesPercentage_7_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[7]*100.0)-77.807)/(11.925); + + double averageDuration_2 = (((double)modelInputs[2].workDurationFeatures.averageDuration.count()*1.0)-10657314.0)/(8410847.0); + + double maxDuration_2 = (((double)modelInputs[2].workDurationFeatures.maxDuration.count()*1.0)-14131266.0)/(11521765.0); + + double numDurations_2 = (((double)modelInputs[2].workDurationFeatures.numDurations*1.0)-4.728)/(1.757); + + double numMissedDeadlines_2 = (((double)modelInputs[2].workDurationFeatures.numMissedDeadlines*1.0)-0.255)/(0.492); + + + if (maxDuration_2 <= -0.026791250333189964) { + if (averageDuration_2 <= -0.7279908359050751) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5294590890407562) { + if (numDurations_2 <= 1.008537232875824) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6656990349292755) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.793600857257843) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6385158896446228) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4029465913772583) { + if (averageDuration_2 <= -0.8630593419075012) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.999062180519104) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4448178857564926) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7462396025657654) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.807902604341507) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1997819542884827) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6782965660095215) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5534783899784088) { + if (maxDuration_2 <= -0.9424203336238861) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9708740413188934) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18576709181070328) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + if (averageDuration_2 <= -0.7325868010520935) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660716414452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15966938436031342) { + if (averageDuration_2 <= -0.81643345952034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2880512475967407) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8521246910095215) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.8048487901687622) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02268711570650339) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36878520250320435) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (maxDuration_2 <= -0.982558399438858) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5429504811763763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.8509195744991302) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307503938674927) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8801776468753815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7419779002666473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5142775774002075) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20717477053403854) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8374143540859222) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1858297809958458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7919849455356598) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8659482300281525) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04485604353249073) { + if (averageDuration_2 <= -0.8259985744953156) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3296032249927521) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7406187653541565) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027660191059) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7856765985488892) { + if (averageDuration_2 <= -0.7858535647392273) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28805113583803177) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.249650239944458) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15979284793138504) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8545561730861664) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.014108333503827453) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22261355817317963) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2336626723408699) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8422523438930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1892642006278038) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6118060946464539) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514787554741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (averageDuration_2 <= -0.8123093843460083) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34767337143421173) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1881876587867737) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.702006757259369) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0825804471969604) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (maxDuration_2 <= -0.8084281384944916) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.009550269693136215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.124604046344757) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4410908222198486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3819774985313416) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1252619624137878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7783321738243103) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9610280096530914) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.128638505935669) { + if (numDurations_2 <= -0.12976674735546112) { + if (averageDuration_2 <= -0.7716651260852814) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29844218492507935) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25889673084020615) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7802900969982147) { + if (averageDuration_2 <= -0.7590159475803375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (averageDuration_2 <= -0.7807428240776062) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5737024396657944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6693927943706512) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9587630033493042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.669339179992676) { + if (maxDuration_2 <= -0.5937521755695343) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6212260723114014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35666845738887787) { + if (numDurations_2 <= 0.43938523530960083) { + if (maxDuration_2 <= -0.6625628769397736) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (averageDuration_2 <= -0.9197312891483307) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5063809156417847) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5355078279972076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7482168078422546) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485123872756958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.665353000164032) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9627330005168915) { + if (maxDuration_2 <= -0.8382506370544434) { + if (averageDuration_2 <= -0.9786600768566132) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.115205705165863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485749125480652) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13047323748469353) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485448718070984) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0810239911079407) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -1.0650984644889832) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.290571391582489) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.798003762960434) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8714832663536072) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2974159121513367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7390552461147308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8903607726097107) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7244215905666351) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.412794589996338) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -1.082964539527893) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2486878037452698) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (averageDuration_2 <= -0.7504191994667053) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7536594271659851) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.982262134552002) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485732734203339) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.1465429225936532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (maxDuration_2 <= -0.8526692688465118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5403872728347778) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485884726047516) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7290031909942627) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7065938413143158) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4990687072277069) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3595471978187561) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4661378264427185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998762696981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2695041596889496) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483214735984802) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0920391082763672) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (maxDuration_2 <= -1.0006976127624512) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (averageDuration_2 <= -1.1075791716575623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.9811021089553833) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3706755638122559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484733760356903) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6645813286304474) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0538491606712341) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (averageDuration_2 <= -1.0037696361541748) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (maxDuration_2 <= -0.762705534696579) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485300004482269) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1782538890838623) { + if (maxDuration_2 <= -0.7995359301567078) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (averageDuration_2 <= -1.017680048942566) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44464120268821716) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (maxDuration_2 <= -0.6713056862354279) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8004915118217468) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7006858289241791) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (maxDuration_2 <= -1.093822181224823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -1.0698245763778687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2591288760304451) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3276389241218567) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8089441657066345) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134997367859) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.9023339152336121) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (averageDuration_2 <= -0.7547591924667358) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42605963349342346) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484579682350159) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.7876474559307098) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8116812705993652) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8949894607067108) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (averageDuration_2 <= -1.0324994325637817) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291386604309082) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6712364256381989) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3440431952476501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.8053693175315857) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (maxDuration_2 <= -0.5827248692512512) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0910795331001282) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0192663073539734) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (maxDuration_2 <= -0.4381233751773834) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2126021981239319) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.16794336587190628) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6002258956432343) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1257103085517883) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2217496633529663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.28815507888793945) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8256843090057373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (averageDuration_2 <= -1.0750052332878113) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.372316062450409) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -1.0310088396072388) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290863573551178) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.593749612569809) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8860599100589752) { + if (maxDuration_2 <= -1.0125353336334229) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290655255317688) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -1.0245479345321655) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291636347770691) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.332153081893921) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935025334358215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4176243543624878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3881487250328064) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (maxDuration_2 <= -0.8473252952098846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.011462688446045) { + if (maxDuration_2 <= -0.9751932919025421) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (maxDuration_2 <= -1.0013231039047241) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485115826129913) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3929442167282104) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.7434191703796387) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3224369883537292) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (maxDuration_2 <= -1.0356639623641968) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478798627853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7658469378948212) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1603711247444153) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -1.104837954044342) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -1.022375226020813) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486274838447571) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.067899227142334) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8523993194103241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.721329003572464) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3179619908332825) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7136523425579071) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6694351136684418) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0439650416374207) { + if (maxDuration_2 <= -0.7408533990383148) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (averageDuration_2 <= -1.0600709319114685) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.798312246799469) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.15082854684442282) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.7229069173336029) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1945740580558777) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6508769392967224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (averageDuration_2 <= -1.09579998254776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7092162072658539) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8627604842185974) { + if (averageDuration_2 <= -1.1154521703720093) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.324838638305664) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.456205427646637) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7159715294837952) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -1.0431328415870667) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9022583663463593) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.1541765332221985) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8366779685020447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3464956879615784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6548356413841248) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.319907307624817) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485126256942749) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.943664014339447) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19243766367435455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (numDurations_2 <= -0.6989187151193619) { + if (averageDuration_2 <= -0.8178204894065857) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484993934631348) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25626495480537415) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.057180069386959076) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7479124367237091) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18317823857069016) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17696937173604965) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660639286041) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.615404963493347) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19949306547641754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (averageDuration_2 <= -0.9237876832485199) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15325802564620972) { + if (averageDuration_2 <= -0.8484043776988983) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8759194314479828) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.7439041435718536) { + if (averageDuration_2 <= -0.7913648784160614) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.328986257314682) { + if (maxDuration_2 <= -0.8749291300773621) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (averageDuration_2 <= -0.7570918500423431) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9367332756519318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883544683456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21903568506240845) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1055833101272583) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5596029758453369) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2751573249697685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (maxDuration_2 <= -0.7782309353351593) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10079115629196167) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2810237780213356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.522695928812027) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.022702748887240887) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6542698442935944) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.498589336872101) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2977132797241211) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.484076499938965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.37633462250232697) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3589812219142914) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7635813057422638) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5270598828792572) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04836024343967438) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4409313201904297) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9852244257926941) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10489858314394951) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7000170946121216) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7541444897651672) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1342943236231804) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3309882879257202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7855533957481384) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.325316846370697) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5625047087669373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07949809357523918) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9174911379814148) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12433211132884026) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2214198112487793) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.8484044969081879) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6256552934646606) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.34173186123371124) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6359044015407562) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.8478683531284332) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3074566572904587) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (maxDuration_2 <= -0.8999521434307098) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5392862558364868) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8850802183151245) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4507238566875458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23827126622200012) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.191137671470642) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2733210325241089) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9289696514606476) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3049383759498596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7651601135730743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8721301257610321) { + if (maxDuration_2 <= -1.087277591228485) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5530383288860321) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460499584675) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8034992218017578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9861829578876495) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.8056600987911224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3963569551706314) { + if (maxDuration_2 <= -0.6239646971225739) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (averageDuration_2 <= -0.9451044499874115) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7646843791007996) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1657530665397644) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3167414665222168) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6046102643013) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.753178060054779) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4912053346633911) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7765167653560638) { + if (averageDuration_2 <= -0.7967119216918945) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7325031757354736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.062578484416008) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5499763190746307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4551285654306412) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19082243740558624) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6055012345314026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.9889333248138428) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7877056896686554) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111890792847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.7872776687145233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -1.1081679463386536) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.196877159178257) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (averageDuration_2 <= -1.1412955522537231) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4030397981405258) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5799986124038696) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485122084617615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4941857010126114) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5282128751277924) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13804925233125687) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= -0.9004054963588715) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (maxDuration_2 <= -1.089655876159668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.8049863278865814) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2332678660750389) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484758198261261) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580028533935547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13301532715559006) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17914728075265884) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0686674118041992) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (maxDuration_2 <= -0.8461932241916656) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748550534248352) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485066950321198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -1.1310508251190186) { + if (maxDuration_2 <= -1.1041352152824402) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -1.0320016741752625) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8897529244422913) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47318921983242035) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7157747745513916) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49814507365226746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23978467285633087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20526859164237976) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.1395784616470337) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29826971888542175) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20997002720832825) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6463401019573212) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5713790655136108) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23155014961957932) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15803858637809753) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06527462415397167) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39870502054691315) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.040801865980029106) { + if (maxDuration_2 <= -0.9549140334129333) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7479974031448364) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.564881682395935) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6878324151039124) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.5332252085208893) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1633485108613968) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11260824277997017) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22887099534273148) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2915659546852112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -1.140200674533844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3810065984725952) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185136318207) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -1.1380121111869812) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4480827897787094) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (maxDuration_2 <= -1.0588330030441284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (averageDuration_2 <= -1.1142973899841309) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.6132869720458984) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.940060019493103) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -1.1839643120765686) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4167131036520004) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7928220629692078) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432608023285866) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485372722148895) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25500111281871796) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4433571398258209) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1368951499462128) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.29344412684440613) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5569165647029877) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748504251241684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4129102826118469) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2595621347427368) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484140992164612) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.956305742263794) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5128677189350128) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3290051817893982) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -1.1089548468589783) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36147835850715637) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43823234736919403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.1214942336082458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27989813685417175) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34007662534713745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.650585949420929) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8793986439704895) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484335899353027) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.585800975561142) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.0597599148750305) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.774457573890686) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3154873698949814) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.410577729344368) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.1272118091583252) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.1182195544242859) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3294856548309326) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290586113929749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45513541996479034) { + if (averageDuration_2 <= -1.1407842636108398) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (averageDuration_2 <= -1.153757095336914) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -1.1777567267417908) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.0963597893714905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0018962721806019545) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6160155534744263) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24204548448324203) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32469581067562103) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (maxDuration_2 <= -1.0964332818984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05494352802634239) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (averageDuration_2 <= -1.1256576776504517) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0985351204872131) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12668081000447273) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22425073385238647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -1.1228739619255066) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (averageDuration_2 <= -1.122932255268097) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06831392273306847) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06436162441968918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22102025151252747) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7477732002735138) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6346259713172913) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5499963164329529) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1307147890329361) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15059547871351242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.1402334570884705) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.1397899985313416) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03372570127248764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (maxDuration_2 <= -1.1058523654937744) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0675973296165466) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7431033551692963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.750402182340622) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.1558533310890198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6642155051231384) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310435295105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5621910691261292) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9838799834251404) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7207823097705841) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0798861384391785) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.1226099729537964) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7803060412406921) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7469508945941925) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2698152661323547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9945657849311829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6893576681613922) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1882601976394653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3427407145500183) { + if (maxDuration_2 <= -1.0071660876274109) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.0788211226463318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.1132931113243103) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2492858171463013) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (averageDuration_2 <= -1.1099023818969727) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8568262457847595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2493610382080078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -1.0630777478218079) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.293446958065033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.645003616809845) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (averageDuration_2 <= -1.1261913776397705) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= -1.1293945908546448) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.141859531402588) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3091135025024414) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8414449393749237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3189390897750854) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4452131986618042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (averageDuration_2 <= -1.116133689880371) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.219297170639038) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485448718070984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2872317433357239) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7781811356544495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2823991179466248) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1331097483634949) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4971318393945694) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07649283856153488) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -1.0660613179206848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -1.1754996180534363) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8961713314056396) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.6003679037094116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2446881532669067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29564088582992554) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44187532365322113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4203786849975586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0664233565330505) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13344067335128784) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9925671517848969) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5491896569728851) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -1.1565128564834595) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484368085861206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544506549835) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3722195290029049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5361638367176056) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29309070110321045) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.1422556042671204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5814048945903778) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4170650690793991) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748243510723114) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -1.1186827421188354) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485456764698029) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8992343544960022) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.1163416504859924) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3006293773651123) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2870839834213257) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.1219031810760498) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4825650155544281) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485326826572418) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -1.137685775756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.00989900529384613) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22730571031570435) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48858194053173065) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (averageDuration_2 <= -1.1187191605567932) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0908224768936634) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -1.0905017256736755) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482313215732574) { + if (maxDuration_2 <= -0.8492147624492645) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7589414715766907) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9046396017074585) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.146455705165863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9640999138355255) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2574796080589294) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6793947815895081) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485446035861969) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28983114659786224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.995596170425415) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.6241148114204407) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2931597232818604) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6645732223987579) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.096486747264862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.267604112625122) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3365567922592163) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6465607583522797) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5373351275920868) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (averageDuration_2 <= -1.137927234172821) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.0650532245635986) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.0629612803459167) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.1179692149162292) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2914859652519226) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291255176067352) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -1.0128164887428284) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6490658521652222) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8023571372032166) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6977249085903168) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4611208140850067) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5552370846271515) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (averageDuration_2 <= -1.141780138015747) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.735918045043945) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31833410263061523) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5859968364238739) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3685400187969208) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21740715950727463) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0708580613136292) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.315876007080078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.087334394454956) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (averageDuration_2 <= -1.1477850675582886) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (maxDuration_2 <= -0.9759683012962341) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1315630078315735) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.45547060668468475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.1535630226135254) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485639452934265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2754998803138733) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.1744038462638855) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -1.1110510230064392) { + if (averageDuration_2 <= -1.1195054054260254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5838580131530762) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (averageDuration_2 <= -1.114879310131073) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (averageDuration_2 <= -1.1537190675735474) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.243281602859497) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484546899795532) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1226530075073242) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.272092878818512) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.183521330356598) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.0675175189971924) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2874603867530823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6520103812217712) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484167814254761) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2656489610671997) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (maxDuration_2 <= -1.0396681427955627) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3253282308578491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.1322280764579773) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9133457541465759) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5580679178237915) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.109629511833191) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (maxDuration_2 <= -1.007589042186737) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2718964219093323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334689199924469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (maxDuration_2 <= -1.0773165822029114) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2553231716156006) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6969980299472809) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3751095533370972) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.62924525141716) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2853108048439026) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.516241043806076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6896679699420929) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.223183035850525) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (maxDuration_2 <= -1.0638046860694885) { + if (averageDuration_2 <= -1.1372241377830505) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5166559815406799) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3012333512306213) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (averageDuration_2 <= -1.1176881790161133) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= -1.1205242276191711) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3558688759803772) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.055702567100525) { + if (averageDuration_2 <= -1.1123510599136353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7740943133831024) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5441941022872925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26742315106093884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2561483234167099) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -1.128945529460907) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485960423946381) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6610177159309387) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8799616694450378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.1850348711013794) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8150440752506256) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -1.0613073706626892) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10163532942533493) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5637430548667908) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (maxDuration_2 <= -1.064944326877594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.8018508851528168) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0102055072784424) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6725481450557709) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0161080360412598) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46217596530914307) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5910212397575378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (averageDuration_2 <= -1.182005763053894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2398325353860855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9425708949565887) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -1.0565231442451477) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6828773617744446) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9259222149848938) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5396436750888824) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (averageDuration_2 <= -1.165008306503296) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7626075446605682) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984920978546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4171066880226135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0290232300758362) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16243278235197067) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20053710788488388) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.746919572353363) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (averageDuration_2 <= -0.8615172803401947) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.103577435016632) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6781022250652313) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0395591855049133) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290246367454529) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8222339451313019) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484205961227417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.690058559179306) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.1034157276153564) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3259271383285522) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8028539419174194) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0166458487510681) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2148973941802979) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.075992226600647) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.9251650869846344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.011162791401147842) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (averageDuration_2 <= -1.0036506056785583) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0031773447990417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (averageDuration_2 <= -0.9910686016082764) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1960631608963013) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0330615639686584) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8791232407093048) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (averageDuration_2 <= -1.0392404794692993) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3057581782341003) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291138350963593) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8382760286331177) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3085800409317017) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.353880524635315) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1415292024612427) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (maxDuration_2 <= -0.8486828505992889) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486014664173126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.8208815157413483) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03977970778942108) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291495382785797) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3835671544075012) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484742105007172) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.279007613658905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291606843471527) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2395784854888916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.293201744556427) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.1055301427841187) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484611868858337) { + if (maxDuration_2 <= -0.8870227634906769) { + if (maxDuration_2 <= -1.016235589981079) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485959231853485) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.42821288108825684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290784001350403) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.7927488684654236) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3408833146095276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484934329986572) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2578762769699097) { + if (averageDuration_2 <= -0.99959397315979) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.9985058009624481) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5951237082481384) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4450313597917557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3735745549201965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0582000017166138) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3435497879981995) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3432283401489258) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -1.0291948318481445) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291636347770691) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485564947128296) { + if (maxDuration_2 <= -1.0079740285873413) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291537702083588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3618700504302979) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0404698252677917) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.9014565646648407) { + if (averageDuration_2 <= -1.0025625824928284) { + if (averageDuration_2 <= -1.0045748353004456) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7505954504013062) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.9109541475772858) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (averageDuration_2 <= -1.0090680122375488) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3156716227531433) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (averageDuration_2 <= -1.0202637910842896) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.9819860458374023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -1.0333681106567383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3526669144630432) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4779665470123291) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0836245734244585) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.8955654799938202) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2370771765708923) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (maxDuration_2 <= -1.0439560413360596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (maxDuration_2 <= -0.9798687100410461) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3533889651298523) { + if (averageDuration_2 <= -1.0105772018432617) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291155636310577) { + if (averageDuration_2 <= -1.0635351538658142) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9443375766277313) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.0271289348602295) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9660933315753937) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (averageDuration_2 <= -1.0499039888381958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -1.0965925455093384) { + if (maxDuration_2 <= -1.0142803192138672) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485727369785309) { + if (maxDuration_2 <= -1.0478968024253845) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2388505339622498) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2858697175979614) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1326680779457092) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + if (maxDuration_2 <= -0.9291287362575531) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (maxDuration_2 <= -1.0100711584091187) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -1.0765565037727356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.776446670293808) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2316191792488098) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2946311831474304) { + if (averageDuration_2 <= -1.0315203070640564) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485194206237793) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291480481624603) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9073147475719452) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3776030540466309) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9809982776641846) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (maxDuration_2 <= -0.9487824141979218) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291636347770691) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9437018036842346) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1953186392784119) { + if (averageDuration_2 <= -1.031644582748413) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3407495021820068) { + if (maxDuration_2 <= -0.9094776213169098) { + if (averageDuration_2 <= -1.0095507502555847) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.026091456413269) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9379222691059113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (maxDuration_2 <= -0.5897175669670105) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0174895524978638) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -1.0254319906234741) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291250109672546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2290045022964478) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291621744632721) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3580281734466553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.9201250672340393) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3264674544334412) { + if (maxDuration_2 <= -0.9943784773349762) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.373979091644287) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485708594322205) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291666150093079) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.238252580165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3212879300117493) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484552562236786) { + if (maxDuration_2 <= -0.9854862093925476) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484790980815887) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -1.0137358903884888) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.309950828552246) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.153515100479126) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.895470380783081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1548801064491272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.329683005809784) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1603711247444153) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (maxDuration_2 <= -1.0328804850578308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (averageDuration_2 <= -1.0020147562026978) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.996011883020401) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (averageDuration_2 <= -0.9589091241359711) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291447103023529) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.333849310874939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.9343993067741394) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.358282208442688) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.006304919719696) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -1.0209115743637085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.8532240092754364) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2533465027809143) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719368040562) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0175373554229736) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3487576246261597) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (maxDuration_2 <= -1.0326449871063232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3946805000305176) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0142674446105957) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2284963726997375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.302737057209015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.258596420288086) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4097040891647339) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8591063022613525) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3629204630851746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (averageDuration_2 <= -1.084696352481842) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3495246767997742) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.1083666682243347) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3164162039756775) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485759854316711) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290714859962463) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (maxDuration_2 <= -1.0301071405410767) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291458129882812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -1.0741679072380066) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (maxDuration_2 <= -1.0176209807395935) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3661340475082397) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (maxDuration_2 <= -0.9992057681083679) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3643078804016113) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560847997665405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.0932592749595642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748575747013092) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -1.013224184513092) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (averageDuration_2 <= -1.0937368273735046) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2078545093536377) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2918504476547241) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.9039714932441711) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.275696337223053) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2909134030342102) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -1.0194166898727417) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.278516173362732) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3090343475341797) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.776604950428009) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12511983513832092) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35822854936122894) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9262494146823883) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5267306864261627) { + if (maxDuration_2 <= -0.9793418943881989) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485418617725372) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6754679083824158) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.0883920788764954) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= -0.8678130507469177) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2927677631378174) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484774589538574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.1069640517234802) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6058647334575653) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5080847293138504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6019909977912903) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27418074011802673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7072018086910248) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5043977797031403) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21653826534748077) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5694662630558014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.002798607514705509) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482759952545166) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.041945893317461014) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451375007629) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -1.0482057332992554) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -1.013658881187439) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22610047459602356) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.9639259874820709) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (averageDuration_2 <= -1.0266461372375488) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307503938674927) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7479949593544006) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484270632266998) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.8138405978679657) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4330156445503235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (averageDuration_2 <= -1.0733472108840942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6992211043834686) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -1.0039239525794983) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1754368171095848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.767163097858429) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.7628245055675507) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0760880745947361) { + if (averageDuration_2 <= -0.882167398929596) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4757819175720215) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6059380620718002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.8073264360427856) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484400868415833) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (maxDuration_2 <= -0.837224930524826) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.011230662930756807) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6162385642528534) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.87022864818573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (averageDuration_2 <= -0.9237387180328369) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2301260605454445) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.9627688527107239) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.9140808880329132) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485543489456177) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.02178550325334072) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.055817024782299995) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6487291157245636) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7134412527084351) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794910855591297) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (averageDuration_2 <= -0.9448301196098328) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4798939824104309) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.628776878118515) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485156059265137) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8483259081840515) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8231029808521271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5337179005146027) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7277982532978058) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.039684925228357315) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0278745293617249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15021001547574997) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7110344171524048) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (averageDuration_2 <= -0.8757037222385406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.09887942299246788) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9695247709751129) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.9502376019954681) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09675727412104607) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142840951681) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0609936211258173) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21617677062749863) { + if (maxDuration_2 <= -0.5133036971092224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.0477152466773987) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6279810667037964) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.9244939684867859) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.9757597744464874) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.910295695066452) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7688092887401581) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7458375096321106) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748376727104187) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.639811635017395) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.140251100063324) { + if (averageDuration_2 <= -1.033181607723236) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.9658706188201904) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.9655709564685822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.022869829088449478) { + if (averageDuration_2 <= -0.9266463816165924) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (maxDuration_2 <= -0.8848167657852173) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250942707062) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0823175422847271) { + if (maxDuration_2 <= -0.7758857011795044) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4441383481025696) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8806194365024567) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28160543739795685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.661453515291214) { + if (averageDuration_2 <= -0.9273856282234192) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6603581607341766) { + if (averageDuration_2 <= -1.08818519115448) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9110248386859894) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485212981700897) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.917200654745102) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8705223202705383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.978966236114502) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.6241148114204407) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (maxDuration_2 <= -1.0592609643936157) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6177415251731873) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8888753354549408) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.663640171289444) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8577660024166107) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9243354201316833) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.0422221422195435) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9282716810703278) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9279386699199677) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9788597226142883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7005505859851837) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953777194023132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.415175676345825) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533683538437) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9499585926532745) { + if (maxDuration_2 <= -1.031692624092102) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0816222429275513) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.352748155593872) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953776597976685) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.103365421295166) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485814094543457) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8522885143756866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.302121102809906) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9463082253932953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8959862291812897) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748512864112854) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.747825026512146) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9700884819030762) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.051196813583374) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.6514046788215637) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7921744287014008) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6337756812572479) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9447527229785919) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.693333387374878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0916350483894348) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.7385993301868439) { + if (averageDuration_2 <= -1.0916545391082764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3946438878774643) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1432478204369545) { + if (maxDuration_2 <= -0.8229405879974365) { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + if (numDurations_2 <= 8.976664543151855) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6376909613609314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5825675427913666) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.4576375484466553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 5.561752796173096) { + if (averageDuration_2 <= -0.953942209482193) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.7809206247329712) { + if (averageDuration_2 <= -0.993834376335144) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966037005186081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5652061998844147) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0064545571804047) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19989652931690216) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6412573456764221) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0507938526570797) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841269969940186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.9281761646270752) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6604832112789154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6822420358657837) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11187028884887695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.66886043548584) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396028995514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5152014791965485) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.563334882259369) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26444411277770996) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18215474486351013) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.112024962902069) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.281239315867424) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.355506181716919) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.8788311779499054) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (averageDuration_2 <= -0.8788748681545258) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06313247233629227) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17581437528133392) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5457973778247833) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485481202602386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3816817998886108) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (averageDuration_2 <= -1.0170779824256897) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (averageDuration_2 <= -0.9041578769683838) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.9968697130680084) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.6698808670043945) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484130263328552) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.027792247012257576) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841110944747925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2079983726143837) { + if (numDurations_2 <= 4.4234490394592285) { + if (averageDuration_2 <= -0.9538386166095734) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6842078566551208) { + if (maxDuration_2 <= -0.9733977913856506) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855916082859) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.8656270802021027) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02118045464158058) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + if (maxDuration_2 <= -0.898113340139389) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5807899236679077) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8408733010292053) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0536000095307827) { + if (maxDuration_2 <= -0.7560242712497711) { + if (averageDuration_2 <= -0.8758251070976257) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4758338928222656) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.354511559009552) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484676837921143) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392571926117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178903579712) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3998583555221558) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5077452659606934) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4352146238088608) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322239637375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08883156627416611) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7423033118247986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484189569950104) { + if (maxDuration_2 <= -0.779920369386673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11246630921959877) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.920729398727417) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.46180689334869385) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8805562555789948) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15291116386651993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8539432883262634) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.082202672958374) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9231627583503723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01659174868836999) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344535857439041) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8461021780967712) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8460337817668915) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.266273260116577) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12437156587839127) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= -0.6712373495101929) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.891006201505661) { + if (maxDuration_2 <= -0.8950994908809662) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8590781688690186) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.992385745048523) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.9026017785072327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768865585327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8292393684387207) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8686310648918152) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9052177369594574) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.7807104587554932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5946841537952423) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9364836812019348) { + if (maxDuration_2 <= -1.0379889607429504) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2520565390586853) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484628260135651) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8231029808521271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.8958566188812256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5129390954971313) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.340703547000885) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9458115994930267) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290536344051361) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291123449802399) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -1.1059884428977966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.333953857421875) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.6241148114204407) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8072429001331329) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.9786150455474854) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9032621681690216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (maxDuration_2 <= -1.0346482992172241) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8009517192840576) { + if (averageDuration_2 <= -1.0396010875701904) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.7084318399429321) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (maxDuration_2 <= -0.9380868971347809) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3208355903625488) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9781692326068878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -1.0808135867118835) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291428327560425) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -1.0082728862762451) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -1.0470492839813232) { + if (maxDuration_2 <= -1.0097190141677856) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3530665636062622) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.9394367933273315) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.391759991645813) { + if (maxDuration_2 <= -0.9039310216903687) { + if (averageDuration_2 <= -0.9916525185108185) { + if (maxDuration_2 <= -0.9561145901679993) { + if (maxDuration_2 <= -0.9744209051132202) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8763347864151001) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (averageDuration_2 <= -0.9914280474185944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (maxDuration_2 <= -0.9863777756690979) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.516241043806076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748517245054245) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485286295413971) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485889792442322) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.088093876838684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3786866664886475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (averageDuration_2 <= -1.0733158588409424) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.9483543634414673) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (maxDuration_2 <= -1.002541422843933) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= -1.0458515286445618) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.8280794322490692) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3287401795387268) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (maxDuration_2 <= -0.996693342924118) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3200352787971497) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291465580463409) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2928558588027954) { + if (averageDuration_2 <= -1.0901435017585754) { + if (maxDuration_2 <= -1.0209894180297852) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485838532447815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.023582935333252) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.8697293996810913) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3870866298675537) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3889294266700745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.018624484539032) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.9040627181529999) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3347746133804321) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9126637279987335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.9230527877807617) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9986079931259155) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9123598039150238) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2980167865753174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (averageDuration_2 <= -0.979499101638794) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3433220982551575) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3933184146881104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290392696857452) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9992134273052216) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9148620963096619) { + if (maxDuration_2 <= -0.9400521814823151) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.9727847576141357) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2249104976654053) { + if (averageDuration_2 <= -1.0350574851036072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.6241148114204407) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485148012638092) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2908489108085632) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4031410217285156) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (maxDuration_2 <= -0.9574720561504364) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9325859248638153) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291450679302216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.19608074426651) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3529844880104065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.9873325228691101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3575220704078674) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3909773230552673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -1.0727104544639587) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (averageDuration_2 <= -1.0448351502418518) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.9581660330295563) { + if (maxDuration_2 <= -0.9952649772167206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8883399069309235) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.7352620959281921) { + if (averageDuration_2 <= -0.9763303101062775) { + if (averageDuration_2 <= -1.008787453174591) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3895283341407776) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -1.0223047733306885) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.9452011585235596) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (averageDuration_2 <= -1.0656272172927856) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3391226530075073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -1.0486800074577332) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.9832042157649994) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485884726047516) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (averageDuration_2 <= -1.079748272895813) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -1.0366896390914917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.371837317943573) { + if (maxDuration_2 <= -0.9468651711940765) { + if (averageDuration_2 <= -1.038196325302124) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.6514046788215637) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (averageDuration_2 <= -1.048509955406189) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9516595900058746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.9318969249725342) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3103426694869995) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (averageDuration_2 <= -1.0972296595573425) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291368722915649) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.9877152144908905) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (averageDuration_2 <= -0.9931288659572601) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (maxDuration_2 <= -0.9733470380306244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.37211674451828) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2964827418327332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.905032753944397) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291350245475769) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3360438346862793) { + if (averageDuration_2 <= -1.0108681917190552) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.0495430827140808) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (averageDuration_2 <= -1.0777165293693542) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3851481080055237) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8972776234149933) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (maxDuration_2 <= -1.0144271850585938) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3684311509132385) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (maxDuration_2 <= -1.031175971031189) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.367152214050293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -1.0555903911590576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (maxDuration_2 <= -0.98959681391716) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486242353916168) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.339514434337616) { + if (maxDuration_2 <= -0.9100348353385925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -1.0199499726295471) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (averageDuration_2 <= -1.0710989832878113) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -1.0238409638404846) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290784001350403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485629916191101) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3965780138969421) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (maxDuration_2 <= -0.9619170129299164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484807074069977) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (maxDuration_2 <= -0.9893383979797363) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485348582267761) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.9396292865276337) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -1.0351310968399048) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9099714756011963) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (maxDuration_2 <= -0.9496714174747467) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8992784917354584) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -1.034917414188385) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.9425823986530304) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9284405410289764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.369373083114624) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3756117224693298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -1.027065396308899) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9208594560623169) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.333244502544403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.9832404553890228) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -1.0013737678527832) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9981065392494202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4198811501264572) { + if (maxDuration_2 <= -0.8898036181926727) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.8048849701881409) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3577340841293335) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7265906035900116) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3274494409561157) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3157723546028137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5650087893009186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49616678059101105) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6715044975280762) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8017489314079285) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 7.553784370422363) { + if (averageDuration_2 <= -0.7597705721855164) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8760176301002502) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9289570152759552) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (averageDuration_2 <= -0.7855864763259888) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7307918667793274) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485164403915405) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3660469800233841) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8712127804756165) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (maxDuration_2 <= -0.782827764749527) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41890062391757965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.8222870230674744) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.797648012638092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8303461968898773) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8170760273933411) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7086964845657349) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.7740722596645355) { + if (maxDuration_2 <= -0.8465401232242584) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1701493337750435) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6798609495162964) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3846140503883362) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { + if (averageDuration_2 <= -0.8097341656684875) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26049620658159256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8446048498153687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17443285882472992) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8147572875022888) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3472245931625366) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1967049166560173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21005777269601822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7969177663326263) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.872601330280304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354000866413) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40047961473464966) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3504288047552109) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6804893612861633) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7309025526046753) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485351264476776) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6924245655536652) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21900930255651474) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06269081309437752) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27543139457702637) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.6958677172660828) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46088892221450806) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01030308729968965) { + if (maxDuration_2 <= -0.4091441333293915) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098746106028557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.4360894709825516) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7682372629642487) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484920918941498) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19680413603782654) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 6.984632730484009) { + if (averageDuration_2 <= -0.804353803396225) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08209078013896942) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5401929020881653) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (maxDuration_2 <= -0.8085852265357971) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17122217267751694) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8194015324115753) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10589347779750824) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1428089737892151) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547075271606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8407254815101624) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5809812843799591) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8322125673294067) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.31137724965810776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.009050487540662289) { + if (averageDuration_2 <= -0.8191673755645752) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7047204077243805) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.058030130341649055) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8483368158340454) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4710201323032379) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.8106747269630432) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484287023544312) { + if (maxDuration_2 <= -0.6322415769100189) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485196888446808) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.7975149154663086) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6420243680477142) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7787678837776184) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7515895664691925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1731696724891663) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2006777748465538) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7419438064098358) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26414854824543) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.558068037033081) { + if (maxDuration_2 <= -0.6657287776470184) { + if (averageDuration_2 <= -0.7823879718780518) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8641326725482941) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36253778636455536) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484583556652069) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7852745056152344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7303554117679596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5335986018180847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7506937682628632) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27654576301574707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7704874575138092) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3755863904953003) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.010587906464934349) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7494457066059113) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5061867833137512) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6422845423221588) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7678030729293823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1402511596679688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0694219321012497) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (maxDuration_2 <= -0.8001918196678162) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2791021913290024) { + if (averageDuration_2 <= -0.7674800753593445) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333690106868744) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.409543216228485) { + if (maxDuration_2 <= -0.7555607855319977) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5259087085723877) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (averageDuration_2 <= -0.7772516906261444) { + if (maxDuration_2 <= -0.7350080907344818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13946834579110146) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5022679567337036) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11960634216666222) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.60592120885849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.7906136512756348) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3343611806631088) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11444881185889244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5819416642189026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748463898897171) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.6822571754455566) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484287023544312) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484880089759827) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.565395325422287) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.026673121377825737) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= -0.7672642171382904) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7560528814792633) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7294158041477203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841269969940186) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7507732510566711) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.768003910779953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.7389311790466309) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5059250891208649) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5468851327896118) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08836853131651878) { + if (averageDuration_2 <= -0.7336152493953705) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20819544792175293) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (maxDuration_2 <= -0.7308290600776672) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21014228463172913) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3713100403547287) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539415165781975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (maxDuration_2 <= -0.7945186197757721) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281268656253815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746338248253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2036862149834633) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10673816502094269) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406549453735) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485158741474152) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7354689240455627) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.7303845882415771) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.658288836479187) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7358769774436951) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12442873045802116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4443967938423157) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.7586457133293152) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6917275190353394) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7410049736499786) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5110337436199188) { + if (maxDuration_2 <= -0.7470332384109497) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34579451382160187) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5182701945304871) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07736463472247124) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5469163358211517) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.48569732904434204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0892229899764061) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.524711012840271) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5585861504077911) { + if (averageDuration_2 <= -0.808156281709671) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.34318535029888153) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04863450862467289) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (maxDuration_2 <= -0.40298226475715637) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7548709809780121) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2693729996681213) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3172197490930557) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16185331344604492) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8600651919841766) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (averageDuration_2 <= -0.728364109992981) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7788002192974091) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.778833419084549) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11963560804724693) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.096980094909668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.7402895390987396) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17470641434192657) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838244438171) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7800873517990112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485416233539581) { + if (maxDuration_2 <= -0.6745981574058533) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5632779002189636) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3265254646539688) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2853203415870667) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2981659024953842) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35280799865722656) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (averageDuration_2 <= -0.7487162053585052) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3535720854997635) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (maxDuration_2 <= -0.8081015646457672) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4530888795852661) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (averageDuration_2 <= -0.7396259307861328) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5755446553230286) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.029482188634574413) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5955654680728912) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748376727104187) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748598724603653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.7500852048397064) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7715782225131989) { + if (maxDuration_2 <= -0.8088359236717224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5561891198158264) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23766880482435226) { + if (maxDuration_2 <= -0.7444449067115784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.755697101354599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7793063521385193) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27160143852233887) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3584589660167694) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.42826317250728607) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46513141691684723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7067153453826904) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4467850476503372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4677629768848419) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7489094734191895) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (averageDuration_2 <= -0.7506153881549835) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4287114292383194) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8079240918159485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.558201402425766) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6725671291351318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6085982918739319) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435039520264) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.7512843906879425) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (averageDuration_2 <= -0.8169448971748352) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7150377929210663) { + if (maxDuration_2 <= -0.7112336754798889) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.044247906655073166) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4784690886735916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748597651720047) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18149596452713013) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.810246616601944) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.7387859225273132) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04769654758274555) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08401471376419067) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30866384506225586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8135310411453247) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5868465304374695) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3789244443178177) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.26611047983169556) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6386152803897858) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6222222447395325) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7087483108043671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560848295688629) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.42252254486083984) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3854132294654846) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7718890905380249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.351067379117012) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (maxDuration_2 <= -0.7569259107112885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11486370116472244) { + if (maxDuration_2 <= -0.668400764465332) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7339423596858978) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6569108963012695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4774004966020584) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7017494440078735) { + if (maxDuration_2 <= -0.6605721414089203) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.018045739270746708) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3078194260597229) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4607301950454712) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.740927517414093) { + if (averageDuration_2 <= -0.745466411113739) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03981145657598972) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.01904148980975151) { + if (averageDuration_2 <= -0.7517834901809692) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47308366000652313) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485814094543457) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.760990709066391) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24962031096220016) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20398568361997604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5379520058631897) { + if (maxDuration_2 <= -0.7898178696632385) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.7686548233032227) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485602796077728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10941097140312195) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7935891151428223) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7479485273361206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= -0.4694627970457077) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7506117820739746) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (averageDuration_2 <= -0.8141740560531616) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.8011089265346527) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38470418751239777) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4881478250026703) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8034063279628754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8231142461299896) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.7861684858798981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4264446794986725) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12062125280499458) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (averageDuration_2 <= -0.8499613702297211) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7734999358654022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3707921653985977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207121819257736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.7187942266464233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483263611793518) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.8309288024902344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4299721010029316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.038322687149048) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3635319769382477) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29130393266677856) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483864724636078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (maxDuration_2 <= -0.7671505212783813) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3857760578393936) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.777476578950882) { + if (averageDuration_2 <= -0.7794100940227509) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7867705821990967) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15585022419691086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0037497972371056676) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.779547929763794) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16962066292762756) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486128509044647) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.054827746003866196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (averageDuration_2 <= -0.7786392271518707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581474900245667) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7958433032035828) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.00100468477467075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484555244445801) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (maxDuration_2 <= -0.7972743511199951) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.7680263221263885) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3619285821914673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3231155127286911) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (maxDuration_2 <= -0.7142373621463776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7652561068534851) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16892749071121216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.7387859225273132) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { + if (averageDuration_2 <= -0.7570997178554535) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492305755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.009141336660832167) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4811306446790695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2563232034444809) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.184308722615242) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149006992578506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6859598159790039) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11568262428045273) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04693389683961868) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3805430680513382) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19484996795654297) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07424627617001534) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7798847258090973) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (averageDuration_2 <= -0.734499990940094) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484937012195587) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3291929066181183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14679361134767532) { + if (maxDuration_2 <= -0.7612746059894562) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02966201677918434) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (maxDuration_2 <= -0.7252799570560455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5495784282684326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.42060625553131104) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5524210333824158) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05409933067858219) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (maxDuration_2 <= -0.7308847904205322) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0048209726810455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7446087896823883) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13670869916677475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177308797836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7357704937458038) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7405288815498352) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9434244632720947) { + if (maxDuration_2 <= -0.7725425362586975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13366060703992844) { + if (averageDuration_2 <= -0.8268042206764221) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07318418473005295) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1717766672372818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5043977499008179) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5384690761566162) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35187314450740814) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (averageDuration_2 <= -0.8561469614505768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8507293462753296) { + if (averageDuration_2 <= -0.8286662995815277) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29898104071617126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3605804145336151) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09690969809889793) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 6.415480613708496) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4894896000623703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.7577396333217621) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (averageDuration_2 <= -0.7899368703365326) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38061293959617615) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6471123099327087) { + if (averageDuration_2 <= -0.8116014301776886) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (maxDuration_2 <= -0.8320583999156952) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27528607845306396) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3543469160795212) { + if (averageDuration_2 <= -0.7883293032646179) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6729749143123627) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0928865596652031) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7679808139801025) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27417193353176117) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5168068408966064) { + if (averageDuration_2 <= -0.8207181692123413) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13622209429740906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45427730679512024) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385324090719223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + if (maxDuration_2 <= -0.7821717858314514) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4669971764087677) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7945850193500519) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04264286905527115) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.872843623161316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3921894133090973) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5196560025215149) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7712029218673706) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.828738659620285) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (averageDuration_2 <= -0.826255202293396) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.916991949081421) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9165481328964233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06678393855690956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1356804370880127) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.056161461398005486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04012217000126839) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.8427512645721436) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.8175154328346252) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (averageDuration_2 <= -0.8166465759277344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7416684925556183) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6867510378360748) { + if (averageDuration_2 <= -0.8349613845348358) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (averageDuration_2 <= -0.7636381983757019) { + if (maxDuration_2 <= -0.7844056487083435) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2508665844798088) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2062634527683258) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31173577159643173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.0760540664196014) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.021470337640494108) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4687176048755646) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7379308640956879) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825265765190125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2599331811070442) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2124972939491272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32310453057289124) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8882669508457184) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.960871696472168) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7066915333271027) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.7496808469295502) { + if (maxDuration_2 <= -0.6135274469852448) { + if (numDurations_2 <= 4.4234490394592285) { + if (averageDuration_2 <= -0.7683515846729279) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1523475646972656) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11992252990603447) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2102959007024765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11748655885457993) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3408803939819336) { + if (averageDuration_2 <= -0.7919456958770752) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014046289026737213) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31338128447532654) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8233535289764404) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5605475306510925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07926750183105469) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33435337245464325) { + if (maxDuration_2 <= -0.7450171709060669) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.7636755406856537) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.049295997247099876) { + if (averageDuration_2 <= -0.7592782378196716) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08977210894227028) { + if (averageDuration_2 <= -0.7571842670440674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6339916586875916) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5108676254749298) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16801734268665314) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (maxDuration_2 <= -0.5085676610469818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0019657311495393515) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5782906115055084) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2175682634115219) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0152312230784446) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9705563485622406) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.00955027062445879) { + if (maxDuration_2 <= -0.39069122076034546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04848794639110565) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014949262142181) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07047391124069691) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.103241678327322) { + if (maxDuration_2 <= -0.7088706791400909) { + if (averageDuration_2 <= -0.7288474142551422) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.595095157623291) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13486888259649277) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14102506637573242) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (maxDuration_2 <= -0.7495102286338806) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4774004966020584) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3919091820716858) { + if (maxDuration_2 <= -0.7259891331195831) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27443885803222656) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913831710815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.602836936712265) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5402902066707611) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18841099739074707) { + if (maxDuration_2 <= -0.5508053600788116) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7503966689109802) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40274588763713837) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (averageDuration_2 <= -0.7443455457687378) { + if (maxDuration_2 <= -0.7665781378746033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8331692218780518) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.020937333814799786) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7479475140571594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841111093759537) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24590055644512177) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2871558964252472) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0008642720349598676) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27151282131671906) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.24033517390489578) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.054759347811341286) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.552420973777771) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2349560484290123) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02260992582887411) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.7712205648422241) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7782390713691711) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4055350422859192) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (averageDuration_2 <= -0.7466336786746979) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2416770458221436) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.055019253864884377) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.21835857629776) { + if (numDurations_2 <= 4.992600917816162) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.060245608910918236) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7553328275680542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8358139991760254) { + if (averageDuration_2 <= -0.8395074307918549) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.043127499520778656) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7289285659790039) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.1251209378242493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06513987109065056) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7825812995433807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7161718606948853) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (averageDuration_2 <= -0.7467296123504639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8052406013011932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31559309363365173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06794018670916557) { + if (averageDuration_2 <= -0.7434859871864319) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5275508463382721) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03485569637268782) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.15153032913804054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3724527508020401) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2777939885854721) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13173338770866394) { + if (maxDuration_2 <= -0.5172522664070129) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5417258441448212) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.035266198217868805) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.750295102596283) { + if (averageDuration_2 <= -0.8580614924430847) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.37451571226119995) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (maxDuration_2 <= -0.7717751562595367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0196513207629323) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842179775238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26372408866882324) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2653430551290512) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.627381294965744) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2012200579047203) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03368368651717901) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1819276362657547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7596466243267059) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.01584817934781313) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9664072096347809) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (averageDuration_2 <= -0.8049529194831848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7828226983547211) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37503907084465027) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160940885544) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5083929151296616) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (averageDuration_2 <= -0.7709395289421082) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2386455237865448) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3148536682128906) { + if (averageDuration_2 <= -0.7380797863006592) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16941408067941666) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35132333636283875) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3915109634399414) { + if (averageDuration_2 <= -0.7647691071033478) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (averageDuration_2 <= -0.7282002866268158) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2405276894569397) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.535465270280838) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1906251907348633) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.3048789501190186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.8499226570129395) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (maxDuration_2 <= -0.7501257061958313) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9551154375076294) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.010598020628094673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3624454736709595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5697498023509979) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7602118253707886) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9614381194114685) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.851090133190155) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8414449393749237) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.028637409210205) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (averageDuration_2 <= -0.8290962874889374) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.810460776090622) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.8099983930587769) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4910624027252197) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06451795622706413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3244311064481735) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1298779919743538) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3343254327774048) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20367839187383652) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2103499099612236) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10306189209222794) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7718333303928375) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1530070304870605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (maxDuration_2 <= -0.38542306423187256) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3835856020450592) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.0805899500846863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.030746312346309423) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7228586971759796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5396998226642609) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8282915353775024) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3917168974876404) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5423632860183716) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4876760244369507) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.554700255393982) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2264903336763382) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5415737628936768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.615404963493347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31189730763435364) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.575394093990326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.6183395385742188) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1833787560462952) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06869351863861084) { + if (averageDuration_2 <= -0.7959124147891998) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1110856905579567) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4753562211990356) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.001128285628510639) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6025357842445374) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06290625967085361) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5768951773643494) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12629788741469383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7588281035423279) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14686497300863266) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9062472879886627) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3425370156764984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5270385146141052) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (maxDuration_2 <= -0.7084603905677795) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1243911124765873) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (averageDuration_2 <= -0.7551696598529816) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (averageDuration_2 <= -0.7899652123451233) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24134959280490875) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1374011039733887) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (averageDuration_2 <= -1.088833510875702) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2942990064620972) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.049710214138031) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291279911994934) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478649914264679) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.313846468925476) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9945657849311829) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0225167274475098) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (maxDuration_2 <= -0.8829830884933472) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0312707424163818) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3544217944145203) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3536303639411926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9861167967319489) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3031083941459656) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (averageDuration_2 <= -1.0905925631523132) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3746796250343323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3128801584243774) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -1.0084855556488037) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3653416633605957) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (maxDuration_2 <= -0.9719997048377991) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (averageDuration_2 <= -1.0828043818473816) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8617412745952606) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560848295688629) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483918368816376) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (maxDuration_2 <= -0.9911088049411774) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.0992709398269653) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -1.044123113155365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (averageDuration_2 <= -1.1002399921417236) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485889792442322) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33595268428325653) { + if (numDurations_2 <= 5.277176856994629) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21208667755126953) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337136715650558) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.283101439476013) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (averageDuration_2 <= -0.8274922966957092) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0155973434448242) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (maxDuration_2 <= -0.4745838940143585) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46035465598106384) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (averageDuration_2 <= -0.8979693949222565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8896448910236359) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2658144682645798) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.435492604970932) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5802961885929108) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6466655731201172) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5478420108556747) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22021745890378952) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.8077267110347748) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2469354197382927) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.129861354827881) { + if (maxDuration_2 <= -0.7125962376594543) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3505440950393677) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8074862062931061) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.9895694851875305) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8199781775474548) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.863024592399597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.173066258430481) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.11133947968482971) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33619174361228943) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7604759037494659) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6577649712562561) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4655948877334595) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.666032075881958) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486244738101959) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19448747485876083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7658452391624451) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5396362543106079) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (maxDuration_2 <= -0.6349666714668274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09281989187002182) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41723044216632843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7657109797000885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14635765552520752) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (averageDuration_2 <= -0.7609040439128876) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1647809147834778) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9748539328575134) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.1006761193275452) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.795674204826355) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8903607726097107) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.009334787726402283) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05917087383568287) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3399442285299301) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13068731129169464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018714666366577) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.0971885919570923) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7824133932590485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21663548797369003) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8184323906898499) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.00591033812816022) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6338953971862793) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3441046476364136) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -1.0331945419311523) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0946163535118103) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (averageDuration_2 <= -1.028170645236969) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3994808793067932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2702754139900208) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6544689238071442) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6477978825569153) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.222243070602417) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -1.0320751070976257) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -1.0839268565177917) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= -1.1043238639831543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8809138834476471) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485256195068359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (averageDuration_2 <= -0.7343926727771759) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48921041190624237) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2624547705054283) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35479700565338135) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1833239197731018) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (averageDuration_2 <= -1.0154385566711426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (averageDuration_2 <= -1.022742748260498) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8723735809326172) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (averageDuration_2 <= -1.0581044554710388) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (averageDuration_2 <= -0.9625106155872345) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2909088581800461) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22980913519859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21007779985666275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2620868980884552) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12123672291636467) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24567920714616776) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (numDurations_2 <= 10.399544715881348) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34722983837127686) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (maxDuration_2 <= -0.9932868182659149) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.348807454109192) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -1.0714022517204285) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (averageDuration_2 <= -1.0794097185134888) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.9417693614959717) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3860049843788147) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (averageDuration_2 <= -1.0624474883079529) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (averageDuration_2 <= -0.7457208037376404) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (averageDuration_2 <= -0.9527964293956757) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8704957962036133) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.272342026233673) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291606843471527) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1274540424346924) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.366221010684967) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.9247268736362457) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9130283892154694) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8903607726097107) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3683481216430664) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748571127653122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (averageDuration_2 <= -1.0647558569908142) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.043817937374115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485749125480652) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6471050083637238) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2802104353904724) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.30548757314682) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (averageDuration_2 <= -1.0991342067718506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0108866095542908) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748216301202774) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.0484581589698792) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2947415709495544) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (maxDuration_2 <= -1.0069177746772766) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (averageDuration_2 <= -1.019023060798645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.324276864528656) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291235208511353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + if (maxDuration_2 <= -0.9674838483333588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.349295973777771) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (maxDuration_2 <= -1.0364946722984314) { + if (maxDuration_2 <= -1.0883793234825134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.911265641450882) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.027217447757721) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.929149329662323) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.219234585762024) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9287984669208527) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2355861067771912) { + if (maxDuration_2 <= -0.9938845634460449) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486149966716766) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8494098782539368) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.361603319644928) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290801882743835) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9090330302715302) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (maxDuration_2 <= -1.0276352763175964) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.301013469696045) { + if (maxDuration_2 <= -1.017808437347412) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.6514046788215637) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.356334924697876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7001149952411652) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -1.0795603394508362) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.263729989528656) { + if (averageDuration_2 <= -1.0237813591957092) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (maxDuration_2 <= -1.0047979354858398) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9130714237689972) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3499057292938232) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3248592019081116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9375144839286804) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (maxDuration_2 <= -0.9984181821346283) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3689538836479187) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9998466074466705) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -1.037847101688385) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3483277559280396) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485980689525604) { + if (maxDuration_2 <= -1.042563021183014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4305726289749146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2693228125572205) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (averageDuration_2 <= -0.9741852581501007) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485354244709015) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.325990617275238) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484465837478638) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (maxDuration_2 <= -0.9180785715579987) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9523028433322906) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.022074043750763) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (averageDuration_2 <= -1.088738739490509) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3730488419532776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6433020830154419) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3165090084075928) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.359628677368164) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.075879156589508) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (averageDuration_2 <= -1.0833644270896912) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3476848006248474) { + if (maxDuration_2 <= -1.0203790664672852) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (averageDuration_2 <= -1.0903875231742859) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (averageDuration_2 <= -1.0534657835960388) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (averageDuration_2 <= -1.0534359216690063) { + if (averageDuration_2 <= -1.0785437226295471) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (maxDuration_2 <= -1.0299527049064636) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.0406447052955627) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (averageDuration_2 <= -1.060453176498413) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.8471353352069855) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2562904953956604) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -1.011329710483551) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.9516645967960358) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9206179678440094) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (maxDuration_2 <= -0.9818314909934998) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984920978546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3035842180252075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8093788325786591) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.8507039248943329) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (maxDuration_2 <= -1.067583441734314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.544535219669342) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.8937292993068695) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3571869134902954) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (maxDuration_2 <= -1.0218986868858337) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (maxDuration_2 <= -1.046838104724884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7438417375087738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7539418935775757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8268132209777832) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4313015341758728) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (averageDuration_2 <= -1.0857316851615906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.9848049581050873) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291172027587891) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -1.076952576637268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7638682126998901) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7210254371166229) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2751178741455078) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (maxDuration_2 <= -1.0485427379608154) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -1.002262830734253) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3124951720237732) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9532829821109772) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.320068597793579) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485754787921906) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485201060771942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9513480365276337) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.9285690188407898) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9086236655712128) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.657477080821991) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (maxDuration_2 <= -0.61098712682724) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.818478524684906) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1799364797770977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.307050883769989) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6865727603435516) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07208741083741188) { + if (averageDuration_2 <= -0.9512304961681366) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8101191520690918) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36744536459445953) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1866874247789383) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.29879215359687805) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1535773053765297) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.928666889667511) { + if (averageDuration_2 <= -0.8126868009567261) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5705733001232147) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495784938335419) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7577928304672241) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1063312888145447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998483300209) { + if (maxDuration_2 <= -0.6981244385242462) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09676655381917953) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.7898687720298767) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5213668942451477) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.5850261449813843) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.797077476978302) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.807980716228485) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35224373638629913) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.039464294910431) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (averageDuration_2 <= -0.8499094545841217) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4602272510528564) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9626529216766357) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5576138496398926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7667542695999146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0650172233581543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5577892959117889) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.062637560069561) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2898678332567215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7450697124004364) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.7643721699714661) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5085248649120331) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5263705551624298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.641837477684021) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.030156010761857033) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (maxDuration_2 <= -0.5654823184013367) { + if (averageDuration_2 <= -0.7754370272159576) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34365224838256836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2509037032723427) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1500561237335205) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7225168645381927) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (maxDuration_2 <= -0.585961639881134) { + if (averageDuration_2 <= -0.7879540622234344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.6245244145393372) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2231253385543823) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8222280740737915) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.846590280532837) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.740801215171814) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2905277609825134) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.468576118350029) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7226000726222992) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.144124150276184) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8669316470623016) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4096873849630356) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251758337021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.043845772743225) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.360865294933319) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8121003806591034) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3674153089523315) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8182219862937927) { + if (maxDuration_2 <= -0.7783652544021606) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36609192192554474) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8812378942966461) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.571122646331787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32004791498184204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7084881961345673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36271806061267853) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3534454703330994) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.987255573272705) { + if (maxDuration_2 <= -0.8230975866317749) { + if (maxDuration_2 <= -0.8670803010463715) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16672417521476746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8627710342407227) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.45564341545105) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2113341093063354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19824778102338314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.070076107978821) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.027829010039567947) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (maxDuration_2 <= -0.4442727714776993) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (maxDuration_2 <= -0.8609030842781067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.62799733877182) { + if (averageDuration_2 <= -0.8092077374458313) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4876449704170227) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3380926549434662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4603784382343292) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7873614430427551) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5305006206035614) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16156639158725739) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7400201857089996) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40182994306087494) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { + if (maxDuration_2 <= -0.6259147822856903) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (averageDuration_2 <= -0.8150107264518738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1274540424346924) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7736139297485352) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2784769684076309) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.017917000222951174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.158513307571411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9567003548145294) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0581600833684206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7815741300582886) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.023027554154396057) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.0423296093940735) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08961186930537224) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8854923248291016) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.7123682498931885) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3777492940425873) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9762924611568451) { + if (averageDuration_2 <= -0.8051114082336426) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8821186125278473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.035035729408264) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9791083335876465) { + if (averageDuration_2 <= -0.810306966304779) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.551266223192215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11914906278252602) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (averageDuration_2 <= -0.7589171528816223) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11723202839493752) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.932972013950348) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5159714818000793) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.049554431810975075) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4404693692922592) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.20488007366657257) { + if (averageDuration_2 <= -0.7373886406421661) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12609514221549034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14933308959007263) { + if (averageDuration_2 <= -0.8941020965576172) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5879328548908234) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.525465726852417) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6781532764434814) { + if (averageDuration_2 <= -0.7552303075790405) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.428275391459465) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.9516345262527466) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7256518006324768) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9957373440265656) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (averageDuration_2 <= -0.7857516705989838) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.36395405419170856) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5959151983261108) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (averageDuration_2 <= -0.8202574551105499) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5912904143333435) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601073861122131) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8322036564350128) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485992908477783) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (maxDuration_2 <= -0.6826016306877136) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8206155002117157) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485056221485138) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998889923096) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6519053876399994) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8579664826393127) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.908483386039734) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6962172985076904) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7747251689434052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (averageDuration_2 <= -0.967249721288681) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501090526581) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (maxDuration_2 <= -0.7286154329776764) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485083043575287) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.608995199203491) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.48212407529354095) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608675241470337) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0035285949707031) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5875498354434967) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2290563583374023) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7390764355659485) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748570054769516) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6304057240486145) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2968019098043442) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.8194639086723328) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7991330921649933) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6855245232582092) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8410574495792389) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.108070135116577) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.556693196296692) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.274079829454422) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3140605241060257) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.536464512348175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.2057141065597534) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2610982060432434) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2260786294937134) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1057260036468506) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.910374104976654) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.5524985790252686) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.066103458404541) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.9108937978744507) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6882593631744385) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7587895691394806) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7395582795143127) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8574993014335632) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462030291557312) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.8118938207626343) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3627567887306213) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8073112964630127) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6400941610336304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.9859343767166138) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.073174238204956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0618832111358643) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1392356753349304) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372235983610153) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6746163666248322) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0712189078330994) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7289382815361023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4597925543785095) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251907348633) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5595023930072784) { + if (maxDuration_2 <= -0.8622657060623169) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.9516109228134155) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.982878804206848) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5582683384418488) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5865647494792938) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8674432635307312) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9597533643245697) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.863292932510376) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818532556295) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4384190440177917) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7578773498535156) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3433197736740112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.61558598279953) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461646318435669) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0396477580070496) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805474296212196) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.8717793822288513) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.9615209102630615) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.7217859029769897) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.795897483825684) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.6132869720458984) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { + if (maxDuration_2 <= -0.9458774328231812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (averageDuration_2 <= -0.8846412301063538) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6951072216033936) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.9395645260810852) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3708256483078003) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1602156162261963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.2314270734786987) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.9530298113822937) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2413274273276329) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.764528274536133) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.679301142692566) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.471769332885742) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5471415519714355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.119468092918396) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.43490731716156) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0439395904541016) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3550583124160767) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.1703981161117554) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { + if (averageDuration_2 <= -0.8530292510986328) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.319916009902954) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998293876648) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736663818359375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.018952965736389) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.549578309059143) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7418413162231445) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.67572283744812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.256853342056274) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7828230559825897) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.5129289031028748) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.8033015727996826) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.4926325678825378) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30152371525764465) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21161343157291412) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.847256302833557) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0225387215614319) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3968586027622223) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7042964100837708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44160401821136475) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8920475542545319) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6531134247779846) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3426513671875) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988372206688) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.283101439476013) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8366457521915436) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23831994831562042) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.0904808733612299) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5383095741271973) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.797360420227051) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284670829773) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28452038764953613) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (averageDuration_2 <= -0.7724689841270447) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2171427085995674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591895639896393) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.9088575839996338) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613043069839478) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.7760578691959381) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7991592884063721) { + if (averageDuration_2 <= -0.8709433376789093) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7416684925556183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3127616047859192) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461722493171692) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7863336503505707) { + if (maxDuration_2 <= -0.8928859829902649) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1735691875219345) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.4638991355895996) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17866874486207962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26936404407024384) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5829523801803589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.536464512348175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7231668531894684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4370013326406479) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.9032242596149445) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17088281363248825) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.151089645922184) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (averageDuration_2 <= -0.8464143574237823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5615230202674866) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616482853889465) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.4015178084373474) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.31817765533924103) { + if (maxDuration_2 <= -0.8368779122829437) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541325807571) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (averageDuration_2 <= -0.83953657746315) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8798000514507294) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.9225641787052155) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.7835445404052734) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.2841893434524536) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04402453824877739) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.45206883549690247) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483572363853455) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485879063606262) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.8296597898006439) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1186425685882568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.457105815410614) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (maxDuration_2 <= -0.7670060694217682) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.185565710067749) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.04611337184906) { + if (averageDuration_2 <= -0.7643966376781464) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (averageDuration_2 <= -0.8286256194114685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9925618171691895) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (maxDuration_2 <= -0.8978626132011414) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5470573008060455) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606725335121) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46509890258312225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5430884063243866) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.787839263677597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7847545742988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5868000388145447) { + if (averageDuration_2 <= -0.832274466753006) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8141622543334961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.412516085896641) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461449921131134) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5144524872303009) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17117134481668472) { + if (averageDuration_2 <= -0.7487320899963379) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7089187502861023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24699638038873672) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6191835701465607) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5765788853168488) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.446592390537262) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5467016398906708) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.7791004180908203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.394700527191162) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6020592153072357) { + if (maxDuration_2 <= -0.8833401501178741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.48583483695983887) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.436687707901001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.7563062310218811) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (averageDuration_2 <= -0.8906766474246979) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16401898860931396) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7533304393291473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.628063291311264) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7877712547779083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7867129743099213) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588659465313) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.029698560945689678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.617037445306778) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.7944704592227936) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.41568124294281) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.559001550078392) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3190313577651978) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.9112419188022614) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.7767811715602875) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8112927377223969) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5860671103000641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3649913668632507) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5959602892398834) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5331270694732666) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.438681423664093) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3028659224510193) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7853200435638428) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.7533895969390869) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (maxDuration_2 <= -0.7937132716178894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5159908831119537) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484947443008423) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.459179162979126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (maxDuration_2 <= -0.5444355905056) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0247357077896595) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (maxDuration_2 <= -0.7714435458183289) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1967049166560173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3674155473709106) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5709889829158783) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3069580793380737) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.8538601398468018) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748258113861084) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5410775542259216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { + if (maxDuration_2 <= -0.4849882423877716) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5326257944107056) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.9019731879234314) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (maxDuration_2 <= -0.6401866376399994) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.7182124853134155) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482954859733582) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.99435293674469) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.174572467803955) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8013654351234436) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.976491093635559) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1853283047676086) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5528357625007629) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4686937481164932) { + if (averageDuration_2 <= -0.8246043622493744) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5390921235084534) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10593993216753006) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.244322419166565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6650353968143463) { + if (averageDuration_2 <= -0.8208702504634857) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1677500009536743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.255478024482727) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.896321952342987) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482841312885284) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.243561565876007) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3947845697402954) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8188356459140778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8940888941287994) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03271237015724182) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6287902295589447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.411447286605835) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.751625120639801) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08648568764328957) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5553211271762848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8995523154735565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.080251455307007) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280607700348) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5029692947864532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07216671481728554) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5197222828865051) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (maxDuration_2 <= -0.8391194045543671) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (averageDuration_2 <= -0.9175049662590027) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4625393748283386) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.38297484815120697) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6458792686462402) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.0614147782325745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485391795635223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3156655579805374) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4543817043304443) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46019111573696136) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7104299664497375) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6357187926769257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7511109113693237) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5185820460319519) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748451441526413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.8947352766990662) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.375217542052269) { + if (averageDuration_2 <= -0.9879387319087982) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5392486453056335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963484764099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6369246244430542) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7337320744991302) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6141211688518524) { + if (maxDuration_2 <= -0.8520742356777191) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4137760996818542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484254539012909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8948203325271606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.7506709396839142) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484205961227417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.357961893081665) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.591109424829483) { + if (maxDuration_2 <= -0.8939495980739594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0965060442686081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (maxDuration_2 <= -0.776683509349823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.41251611709594727) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6943683922290802) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.01957121305167675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483702301979065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.809019535779953) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4318973124027252) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02121040504425764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8502845764160156) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6725745499134064) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6288670301437378) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4370974451303482) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4400789737701416) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4584023356437683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45933035016059875) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.033246856182813644) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4694384932518005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1981717273592949) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21196596324443817) { + if (maxDuration_2 <= -0.9297112822532654) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.379005551338196) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (maxDuration_2 <= -0.631486713886261) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748290628194809) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (maxDuration_2 <= -0.7409394979476929) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.6672534942626953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3852276802062988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.781402587890625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7147389352321625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5279523432254791) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.7453612089157104) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04735138453543186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392869949341) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6106894314289093) { + if (maxDuration_2 <= -0.7561103999614716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.9713491201400757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12993323057889938) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7312058210372925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11486532539129257) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (averageDuration_2 <= -0.7355318665504456) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (averageDuration_2 <= -0.8994210660457611) { + if (averageDuration_2 <= -0.9288605749607086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.759820818901062) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.071460247039795) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1025575399398804) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8309287428855896) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5364645272493362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.634295254945755) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.538178443908691) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6183218657970428) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.7104121446609497) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.390951991081238) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5065722763538361) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9852243959903717) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7968621850013733) { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9418042302131653) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617576599121094) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2056111916899681) { + if (averageDuration_2 <= -0.7974371314048767) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4241048097610474) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5429091453552246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5106825232505798) { + if (averageDuration_2 <= -0.8818188607692719) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991478800774) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1937887072563171) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.7900145053863525) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6124650537967682) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32995815575122833) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.57896688580513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613218903541565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4709976762533188) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4453221559524536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.319916009902954) { + if (averageDuration_2 <= -0.7746518850326538) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609447717666626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.565750241279602) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6067830920219421) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.515291452407837) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.730912685394287) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4312434196472168) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2084840536117554) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01888130372390151) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5636159181594849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2644413709640503) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5863956212997437) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.70228311419487) { + if (averageDuration_2 <= -0.8299257755279541) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (averageDuration_2 <= -0.8337880373001099) { + if (maxDuration_2 <= -0.829325407743454) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611381888389587) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5009890794754028) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5297839045524597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19721277058124542) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + if (averageDuration_2 <= -0.744540810585022) { + if (averageDuration_2 <= -0.9135403335094452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6959031820297241) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3533594161272049) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (maxDuration_2 <= -0.7604792714118958) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37100014090538025) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5846337378025055) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.851523369550705) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5401993095874786) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4186374396085739) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4517582058906555) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.419839859008789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6947869956493378) { + if (averageDuration_2 <= -0.8420543372631073) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.2126322984695435) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8011052906513214) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4195438027381897) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5771068334579468) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35507284104824066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7996082603931427) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6957186162471771) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.686529815196991) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9793047904968262) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.591629832983017) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.201838493347168) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (numDurations_2 <= -0.12976674735546112) { + if (maxDuration_2 <= -0.7955873906612396) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.541467308998108) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { + if (maxDuration_2 <= -0.8594645261764526) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615896344184875) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1982994675636292) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9351336658000946) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0795066356658936) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.645317256450653) { + if (maxDuration_2 <= -0.891493171453476) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612769484519958) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.777643233537674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8053269982337952) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.8356015980243683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3264200687408447) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.009791374206543) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12180164828896523) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6557523906230927) { + if (averageDuration_2 <= -0.7716197967529297) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6663342416286469) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4413984566926956) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3441053628921509) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3346663564443588) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4285312294960022) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.15136985667049885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9112135469913483) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5918215215206146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5406997203826904) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (averageDuration_2 <= -0.8429698050022125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168212890625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.9233703315258026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5557059049606323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7905055284500122) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7344444096088409) { + if (averageDuration_2 <= -0.835861325263977) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.8001846969127655) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (averageDuration_2 <= -0.8810626566410065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462435781955719) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46883149445056915) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454745411873) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.370543122291565) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.128291368484497) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6762018799781799) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3001596331596375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (maxDuration_2 <= -0.8727992177009583) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1025575399398804) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9234714210033417) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.92511522769928) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9243354201316833) { + if (averageDuration_2 <= -0.8013870716094971) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.013622283935547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6307750940322876) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (maxDuration_2 <= -0.7561863660812378) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2887056469917297) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5630521476268768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2587443590164185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774096846580505) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.562049627304077) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5330886244773865) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.814529538154602) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.262742042541504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609379172325134) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9125365614891052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6684154272079468) { + if (averageDuration_2 <= -0.8119098544120789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614939093589783) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2335663437843323) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3541070222854614) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (averageDuration_2 <= -0.8667159676551819) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.049846856854856014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5630554556846619) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.8768972158432007) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.158935070037842) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.352748155593872) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.457859516143799) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7751853466033936) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.6763077080249786) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7079143524169922) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.448354184627533) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9925618171691895) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6509772539138794) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.450350522994995) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.671301484107971) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.104102611541748) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612173438072205) { + if (averageDuration_2 <= -0.7570270895957947) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.916857600212097) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.156500577926636) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (averageDuration_2 <= -0.7553679347038269) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4858115911483765) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5504419207572937) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8022524118423462) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.392748713493347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.013413906097412) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3638120293617249) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144361093640327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.00955027062445879) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070023775100708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3562923669815063) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4007549285888672) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7220813930034637) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3121556639671326) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8524277210235596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5433805584907532) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.48581835627555847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4203786849975586) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.460392713546753) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.446696937084198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.7644274830818176) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.7172511219978333) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4592690467834473) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0436710715293884) { + if (averageDuration_2 <= -0.8955941796302795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4366065859794617) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8470445275306702) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9618161916732788) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.83527472615242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (averageDuration_2 <= -0.8925842940807343) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (maxDuration_2 <= -0.7636654675006866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8779715001583099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2982683777809143) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.678435742855072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9612837135791779) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991199404001) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0654678046703339) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6104198098182678) { + if (maxDuration_2 <= -0.63309246301651) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4537895917892456) { + if (averageDuration_2 <= -0.8043700456619263) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322981834412) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0594176650047302) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265407919883728) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8112369775772095) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3982304334640503) { + if (maxDuration_2 <= -0.866206556558609) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3102447986602783) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8397803604602814) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.463899254798889) { + if (averageDuration_2 <= -0.8356188237667084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6226453483104706) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5369972586631775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5352232456207275) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8984741270542145) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0211119651794434) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627582550049) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.462875783443451) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8691672086715698) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6074519157409668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.474105715751648) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5143052339553833) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.119892120361328) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (maxDuration_2 <= -0.4563359022140503) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3099656105041504) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7546340823173523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + if (maxDuration_2 <= -0.8522311449050903) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.857142448425293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7372652888298035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3226464986801147) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1889312863349915) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4604092836380005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.7149617671966553) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4523767232894897) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8500410318374634) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4324129819869995) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (maxDuration_2 <= -0.5639347732067108) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.302151679992676) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4589674472808838) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619951248168945) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1097821593284607) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.6281538009643555) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5322485864162445) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5236871242523193) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4978697299957275) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8396687209606171) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9754036664962769) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (averageDuration_2 <= -0.9301751852035522) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8544911742210388) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.33754563331604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461440086364746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7774136662483215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178903579712) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.8246392905712128) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3617719411849976) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.8643160462379456) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8228965401649475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7120643258094788) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.08371102809906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0554805994033813) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.347779631614685) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614352583885193) { + if (maxDuration_2 <= -0.7145614922046661) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.715727150440216) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2169177532196045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.857970118522644) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8915785253047943) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { + if (averageDuration_2 <= -0.8482578098773956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.8247747719287872) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.2966272830963135) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8019542992115021) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580028533935547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5771068334579468) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6995680630207062) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.8361814320087433) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7843496799468994) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (averageDuration_2 <= -0.8498333096504211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.853350043296814) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2188429236412048) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5715272426605225) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8884061872959137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.851856768131256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.546422004699707) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7393279671669006) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7264743447303772) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8978229761123657) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.523591637611389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6214135885238647) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.080590009689331) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.5795979499816895) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7740705013275146) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3197866678237915) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.8120376765727997) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5748943984508514) { + if (averageDuration_2 <= -0.7539332211017609) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7565419673919678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6780604124069214) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.397077739238739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1383355855941772) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1919543147087097) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3274243474006653) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5499634146690369) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.8970294892787933) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.027743935585022) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462475836277008) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.9577589929103851) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111890792847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3659772872924805) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1756895780563354) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5890317857265472) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.8208415508270264) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.776744842529297) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8919272422790527) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8678250908851624) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8072891235351562) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.1589351892471313) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.447493553161621) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8357125520706177) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0489644408226013) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8087358474731445) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.185817003250122) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.568963497877121) { + if (maxDuration_2 <= -0.6538098454475403) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3505582809448242) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.60126531124115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5815747082233429) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335706472396851) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7242187261581421) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0554805994033813) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.399782419204712) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7051274180412292) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.7001581788063049) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4852719902992249) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4965246617794037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (averageDuration_2 <= -0.7830893099308014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (averageDuration_2 <= -0.830251157283783) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9269556701183319) { + if (numDurations_2 <= 2.1468411684036255) { + if (maxDuration_2 <= -0.7728008925914764) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5600056648254395) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0952094793319702) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.805475264787674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.765721470117569) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.3247819542884827) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7221224308013916) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7555134296417236) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6936625838279724) { + if (averageDuration_2 <= -0.8252517282962799) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5546018779277802) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.6747801303863525) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396402455866337) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.069406747817993) { + if (maxDuration_2 <= -0.8413304388523102) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7497578859329224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6291781365871429) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.4106956720352173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0382118225097656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7525787353515625) { + if (averageDuration_2 <= -0.9109514653682709) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.7652508318424225) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8907867670059204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.6557488441467285) { + if (averageDuration_2 <= -0.7331299185752869) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9707030951976776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1119681000709534) { + if (averageDuration_2 <= -0.8989059627056122) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.726304829120636) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7987507879734039) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + if (maxDuration_2 <= -0.8690582811832428) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.802557498216629) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4146862626075745) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1820902824401855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.797151505947113) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.441839575767517) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.9036868214607239) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8480863571166992) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3690998554229736) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.0006468296051025) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591094017029) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8338945508003235) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.528399646282196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.7777704000473022) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.4962093830108643) { + if (averageDuration_2 <= -0.8659754991531372) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.7692475318908691) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0179689228534698) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.585340261459351) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.49310925602912903) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7543118894100189) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.50235915184021) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7039737701416016) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7886603474617004) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.103430151939392) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7192893326282501) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8911315500736237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4073859453201294) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.2786535024642944) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1428000926971436) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (maxDuration_2 <= -0.7683813273906708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6757878959178925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0817551612854004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8740346431732178) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.504205822944641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8454509973526001) { + if (averageDuration_2 <= -0.8810018599033356) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5445061326026917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7542046010494232) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.6304420828819275) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.050779640674591) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1243432760238647) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.7009100914001465) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5913728773593903) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531888961792) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6968811452388763) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.842424064874649) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8415617346763611) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206973910332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (averageDuration_2 <= -0.7859432697296143) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47574737668037415) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8628509640693665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.001366853713989) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.9615209102630615) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.205713987350464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8167448043823242) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825265765190125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1273308992385864) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9933372437953949) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7111651003360748) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.7361153960227966) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.7316962480545044) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0305752158164978) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2619678378105164) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7837395370006561) { + if (maxDuration_2 <= -0.860442191362381) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8088967800140381) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.336305618286133) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.812716007232666) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (maxDuration_2 <= -0.8216032981872559) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.731414794921875) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5439854860305786) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.865355610847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= -0.77240389585495) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5347036123275757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.140251100063324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5930910110473633) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2693904638290405) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.904642939567566) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43952974677085876) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1477268561720848) { + if (maxDuration_2 <= -0.6199504435062408) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435039520264) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.8664522767066956) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36783188581466675) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.184145450592041) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617674350738525) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.950202226638794) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.966834545135498) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17070144414901733) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1134390830993652) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610844254493713) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.827701985836029) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28073687851428986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5708313882350922) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8228538036346436) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609535336494446) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461640477180481) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617537260055542) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1585763804614544) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.180942177772522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.030603766441345) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070023775100708) { + if (maxDuration_2 <= -0.6471641957759857) { + if (averageDuration_2 <= -0.7583030164241791) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7938892543315887) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.0378661155700684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2984808310866356) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.632165789604187) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { + if (averageDuration_2 <= -0.737939715385437) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.6712814569473267) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47478847205638885) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + if (averageDuration_2 <= -0.9875132143497467) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.40158165991306305) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6305099427700043) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.403375267982483) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6404491662979126) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + if (maxDuration_2 <= -0.8833832442760468) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.7318853139877319) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.7993290424346924) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.545168399810791) { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.7418212890625) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8054839074611664) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.162411332130432) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.6660319566726685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -6.315052270889282) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.644861221313477) { + if (maxDuration_2 <= -0.5708287358283997) { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.446711540222168) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612173438072205) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -1.1485382318496704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7475018501281738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1261513233184814) { + if (maxDuration_2 <= -0.7064949870109558) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.9565386176109314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.958153247833252) { + if (maxDuration_2 <= -0.5579375624656677) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.000512957572937) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7984241247177124) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.078379273414612) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.092103958129883) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.084824323654175) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.31877863407135) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.832190155982971) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.520781755447388) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184681713581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.7896812260150909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.06467604637146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.7722208797931671) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.507277250289917) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8576572239398956) { + if (maxDuration_2 <= -0.8372654616832733) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.292544722557068) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.4676418900489807) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461249589920044) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.8604344427585602) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1546188592910767) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + if (numDurations_2 <= 1.008537232875824) { + if (averageDuration_2 <= -0.8215171098709106) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.8410999178886414) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (averageDuration_2 <= -0.8438116610050201) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5224426984786987) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461689293384552) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.135060667991638) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3127616047859192) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9243354201316833) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1968777179718018) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.261699676513672) { + if (maxDuration_2 <= -0.9035385549068451) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862634658813) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.4987709522247314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812395572662354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.9155310392379761) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3302619457244873) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8356302082538605) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.478332042694092) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8394230008125305) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7741955518722534) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1936134099960327) { + if (maxDuration_2 <= -0.8239206075668335) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.8096490502357483) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46695980429649353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 0.15480925142765045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6347068548202515) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461280882358551) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0026546716690063) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424482166767) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701804161072) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.8428181707859039) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.357686996459961) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0236079692840576) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613032937049866) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4474889039993286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613492488861084) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9757651090621948) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (maxDuration_2 <= -0.7930420637130737) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.452039897441864) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.37633462250232697) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5435277223587036) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462590157985687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9791666865348816) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4578933119773865) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (averageDuration_2 <= -0.8867798447608948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.9343047738075256) { + if (maxDuration_2 <= -0.899321436882019) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46121346950531) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006845474243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2985063791275024) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0488998889923096) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615564346313477) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8449939787387848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2308461666107178) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.442385733127594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.125472903251648) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (maxDuration_2 <= -0.7844918668270111) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.062656044960022) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3341875076293945) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1421070098876953) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.057438313961029) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6955958604812622) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.83610799908638) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.1934889554977417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45489123463630676) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3763646483421326) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2084840536117554) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044002512469888) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601445198059082) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1557555198669434) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8948088586330414) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.802190363407135) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.996976375579834) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2016663551330566) { + if (averageDuration_2 <= -0.8924600183963776) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3390844464302063) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.986719846725464) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.095744252204895) { + if (maxDuration_2 <= -0.7987862825393677) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (averageDuration_2 <= -0.8311758041381836) { + if (maxDuration_2 <= -0.8168696165084839) { + if (averageDuration_2 <= -0.8701894283294678) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5493937730789185) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2846933603286743) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.8878712058067322) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (averageDuration_2 <= -0.9031388461589813) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1356128454208374) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462156355381012) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (averageDuration_2 <= -0.8473033607006073) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615212678909302) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.3318238258361816) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7869105041027069) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.036571502685547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615153670310974) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (maxDuration_2 <= -0.880863219499588) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5495784282684326) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.858051985502243) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.8532500565052032) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8408342003822327) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.040866255760193) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1759754419326782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.126484632492065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8452967405319214) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.988785743713379) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988297700882) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.269085645675659) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.0904808733612299) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.741730809211731) { + if (averageDuration_2 <= -0.8489922881126404) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.951748788356781) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616179466247559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604772090911865) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.119327187538147) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.910463809967041) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.253344774246216) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0948941707611084) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1930317878723145) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9705603718757629) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5664471983909607) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.779565453529358) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.962456464767456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098746106028557) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4334494471549988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6957917511463165) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8960155844688416) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5499634146690369) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9332823753356934) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.340226411819458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580028533935547) { + if (maxDuration_2 <= -0.7350233197212219) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5907409191131592) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4631803035736084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.5062687397003174) { + if (maxDuration_2 <= -0.7054971158504486) { + if (averageDuration_2 <= -0.8440606594085693) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8167273998260498) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333690106868744) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3021210432052612) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0927696228027344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7556697726249695) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618534445762634) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.8513839244842529) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9226681292057037) { + if (averageDuration_2 <= -0.8244331181049347) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7522785365581512) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1932445764541626) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2985881567001343) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461289644241333) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7628713846206665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9158918261528015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.18975830078125) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461993157863617) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283631324768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.312325596809387) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.442385733127594) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.500523865222931) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4851264357566833) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177308797836304) { + if (maxDuration_2 <= -0.3808312714099884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1297828555107117) { + if (maxDuration_2 <= -0.6556056439876556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404849529266) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8070490062236786) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (maxDuration_2 <= -0.5255822241306305) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610971808433533) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.609829068183899) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5783230662345886) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615769386291504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0235978364944458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.104984164237976) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999027848243713) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.966140866279602) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9596602916717529) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9846479892730713) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.046812891960144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1022101640701294) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.41617000102996826) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461523175239563) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.94572114944458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8284693658351898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7991330921649933) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5771068334579468) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.572900652885437) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.663603812456131) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.412252426147461) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.203624814748764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461660921573639) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284670829773) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7301533222198486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.219858407974243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8765342235565186) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9056564569473267) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5228672027587891) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.114920973777771) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 5.561752796173096) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.318671464920044) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1802543997764587) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.9680478572845459) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461458683013916) { + if (averageDuration_2 <= -0.768484503030777) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.345606565475464) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.772175431251526) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7509801089763641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + if (maxDuration_2 <= -0.704481452703476) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { + if (maxDuration_2 <= -0.7030530273914337) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.458408236503601) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.189055442810059) { + if (maxDuration_2 <= -0.49114514887332916) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3302619457244873) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7944985032081604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.4876089096069336) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.358807325363159) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4166516661643982) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7356986701488495) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5456278324127197) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4795267730951309) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5627981424331665) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463053226471) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748435765504837) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3514363169670105) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.4767167568206787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.024251937866211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (averageDuration_2 <= -0.7794765532016754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9234713912010193) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701208114624) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.3985434770584106) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614938497543335) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2783265709877014) { + if (maxDuration_2 <= -0.870881974697113) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2460008263587952) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7930554747581482) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295567870140076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4089773893356323) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5897117257118225) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550786972046) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.050149083137512) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1339786052703857) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09959029033780098) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.717830538749695) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.050229251384735) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5457724332809448) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (maxDuration_2 <= -0.7997714877128601) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.9376527667045593) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.274852991104126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3923389911651611) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060720920563) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8236344754695892) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45685142278671265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.3262604475021362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550792455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.8613742291927338) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4839763045310974) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5390901863574982) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.9032377600669861) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.652773082256317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.608930468559265) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12191574275493622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.9914973974227905) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.146611213684082) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533598005771637) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.8945000469684601) { + if (maxDuration_2 <= -0.7379308640956879) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7018108665943146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7048707604408264) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6922209858894348) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.168618083000183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5405655801296234) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4421443939208984) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.5886342525482178) { + if (maxDuration_2 <= -0.695553719997406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.4143427312374115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8960750699043274) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6088766753673553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.8682698607444763) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1611649990081787) { + if (maxDuration_2 <= -0.5970422625541687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5037885308265686) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04885315801948309) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7533897161483765) { + if (maxDuration_2 <= -0.6865323483943939) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9004814624786377) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (maxDuration_2 <= -1.081095278263092) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2268345132470131) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.949642539024353) { + if (maxDuration_2 <= -1.1125970482826233) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -1.0821439623832703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0033336126944050193) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (averageDuration_2 <= -0.8384943306446075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.418287456035614) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4941570311784744) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5577045977115631) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (averageDuration_2 <= -0.8889686763286591) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5929246246814728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36093683540821075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8058282732963562) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (averageDuration_2 <= -0.9070799350738525) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9313026964664459) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36746344715356827) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.4987709522247314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3195142149925232) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (averageDuration_2 <= -0.7981390058994293) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3367941230535507) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8509162068367004) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6012652814388275) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 1.5776892304420471) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8537194430828094) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.291175901889801) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6018891036510468) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484004199504852) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.632410317659378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28166045248508453) { + if (averageDuration_2 <= -0.786058634519577) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8065165877342224) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30791717767715454) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.030746312346309423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7546007633209229) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27897073328495026) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485465109348297) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 8.976664543151855) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3864848017692566) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36378298699855804) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8325167596340179) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6743242144584656) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7768998742103577) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -1.1047683954238892) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.944080650806427) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41109657287597656) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6793991923332214) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8012139797210693) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (averageDuration_2 <= -0.8523324728012085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (averageDuration_2 <= -0.8060285151004791) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (maxDuration_2 <= -0.537627637386322) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.7506955564022064) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913235664368) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2271507978439331) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2443223595619202) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000302791595) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (averageDuration_2 <= -0.777691513299942) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8889637887477875) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.8777441382408142) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.9753090739250183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8439154028892517) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6305421590805054) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -1.028695523738861) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7551562786102295) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27559196949005127) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7601846754550934) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (maxDuration_2 <= -0.35378724336624146) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.934496134519577) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2398325316607952) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8205778300762177) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610415458679) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06391064077615738) { + if (averageDuration_2 <= -0.8721393942832947) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7211587131023407) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2896693348884583) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (maxDuration_2 <= -0.7254219651222229) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8932941854000092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1233071088790894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03168726712465286) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0028385603800415993) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7550351321697235) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406847476959) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -1.117720603942871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8085508942604065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7006680071353912) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (averageDuration_2 <= -0.8070890009403229) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1535773053765297) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470267772675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091150283813477) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (maxDuration_2 <= -0.6245066821575165) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4477521777153015) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616394639015198) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7951833009719849) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988409459591) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8778327703475952) { + if (numDurations_2 <= 1.862265169620514) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + if (maxDuration_2 <= -1.0358437895774841) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.8239940702915192) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638475418091) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.7970774918794632) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4486286044120789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4605225920677185) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8375648558139801) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7063737511634827) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8249529004096985) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (maxDuration_2 <= -0.6585916876792908) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7418249845504761) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7555809319019318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12538408860564232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165755271912) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.9984461069107056) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04191499203443527) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616208672523499) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7631543278694153) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -1.1196978688240051) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.511135220527649) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.484076499938965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06636212021112442) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8568262457847595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5848501920700073) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47639887034893036) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (averageDuration_2 <= -0.830085426568985) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287291735411) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.815709799528122) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5680118203163147) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8356302231550217) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.8237700760364532) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -1.0118963420391083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8168685138225555) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6618636250495911) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4437549114227295) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (maxDuration_2 <= -0.6737751662731171) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7888006269931793) { + if (maxDuration_2 <= -0.7395339608192444) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614401459693909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.507671058177948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.807615339756012) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488866329193) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614381790161133) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6337586343288422) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.293517827987671) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.610805869102478) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4539019465446472) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3692631125450134) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463053226471) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0605764985084534) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.9678915143013) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4124236106872559) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2443223595619202) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3796340823173523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.7895140647888184) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3163074254989624) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485351264476776) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16126471012830734) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7661713361740112) { + if (averageDuration_2 <= -0.8084303438663483) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1680329218506813) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.6698316931724548) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (averageDuration_2 <= -0.8142719864845276) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6955958604812622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (averageDuration_2 <= -0.9147166609764099) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5595702826976776) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (averageDuration_2 <= -0.7695389091968536) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0603214967995882) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5080965459346771) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2754700630903244) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4482031911611557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10645005106925964) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5910808444023132) { + if (maxDuration_2 <= -0.6310662925243378) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6299374103546143) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.9731746912002563) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4205306768417358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0650932528078556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4319772124290466) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13728278875350952) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02273319847881794) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.4987709522247314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.994560718536377) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1754608750343323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7539052069187164) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22462796419858932) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (maxDuration_2 <= -0.7752878963947296) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7867300510406494) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8997635543346405) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (averageDuration_2 <= -0.7776250243186951) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.53995680809021) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6991482973098755) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (maxDuration_2 <= -0.7863051891326904) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5641268491744995) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.8063688576221466) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.903601735830307) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.020337074995041) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841269969940186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.9713491201400757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6038247644901276) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619140028953552) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.9169616103172302) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.007768270559608936) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0299912141636014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06710292771458626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8542775809764862) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22984347492456436) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08151936950162053) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40749405324459076) { + if (averageDuration_2 <= -0.7826807796955109) { + if (maxDuration_2 <= -0.41466568410396576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (maxDuration_2 <= -0.5084206759929657) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5416039228439331) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21511530131101608) { + if (maxDuration_2 <= -0.8260734379291534) { + if (averageDuration_2 <= -0.8654394745826721) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.8078104555606842) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.619788646697998) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4575278759002686) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03518171887844801) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748597651720047) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1718374267220497) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621045589447021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7925673127174377) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6759060919284821) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.31755438446998596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.9395075738430023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8396335542201996) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616394639015198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28946828842163086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794910855591297) { + if (maxDuration_2 <= -0.6634492576122284) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4602226614952087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614762663841248) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2950655072927475) { + if (averageDuration_2 <= -0.7372916340827942) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617488980293274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.7744091749191284) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22714968025684357) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7484507262706757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484799027442932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484554946422577) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.1218186616897583) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24142257124185562) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3981632590293884) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.382701113820076) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.551739454269409) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3938084840774536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5717911720275879) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.330262005329132) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6552769839763641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5906673669815063) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.580150842666626) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9746512174606323) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5707750022411346) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5333273410797119) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7394886910915375) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.7453612089157104) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.649523138999939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.130955457687378) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091154009103775) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.8455296456813812) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (maxDuration_2 <= -0.8251465857028961) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (maxDuration_2 <= -0.7232942879199982) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (averageDuration_2 <= -0.7565992474555969) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617342352867126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.012147903442383) { + if (averageDuration_2 <= -0.7373141646385193) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + if (maxDuration_2 <= -0.6060763299465179) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670051813126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (maxDuration_2 <= -0.5708591938018799) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7570379674434662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.7564848065376282) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6645484864711761) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2839902378618717) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7724799811840057) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6197241842746735) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.1934889554977417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8442182540893555) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1475108861923218) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5499634146690369) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7160786986351013) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1904139518737793) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615055918693542) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5648982524871826) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9343138933181763) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.450029730796814) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.985480934381485) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01303433463908732) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.779975950717926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.8405724167823792) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17575901001691818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3253724277019501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6063745617866516) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057653248310089) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3205846548080444) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24937009811401367) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49690526723861694) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5596505403518677) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1697663068771362) { + if (maxDuration_2 <= -0.8268257677555084) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7237499356269836) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (averageDuration_2 <= -0.9301206469535828) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.211623668670654) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.41470272839069366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8803159296512604) { + if (averageDuration_2 <= -0.8867250084877014) { + if (averageDuration_2 <= -0.8980647921562195) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.5418986082077026) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4670807123184204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4110719561576843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.7327817380428314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3831367492675781) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8619505763053894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9833564758300781) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.125706672668457) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4514347910881042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.278653383255005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.001600444316864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.1397976875305176) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1472140550613403) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025971174240112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812395572662354) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5389954149723053) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.802154541015625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0493888854980469) { + if (maxDuration_2 <= -0.4872220903635025) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4294117093086243) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.528386116027832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6426037847995758) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2793676853179932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04518895223736763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617577195167542) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6843219995498657) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6897867321968079) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4624680280685425) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7947405874729156) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9846312403678894) { + if (maxDuration_2 <= -0.8527984619140625) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6347068548202515) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5336875915527344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33969302475452423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.9710743725299835) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5387052446603775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8252379894256592) { + if (maxDuration_2 <= -0.5665536522865295) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8577800691127777) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7867361903190613) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.353586882352829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3253334313631058) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999027848243713) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7414031326770782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5220772624015808) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.445237159729004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461571991443634) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4507567286491394) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8508365154266357) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8228964507579803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613961577415466) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8356260657310486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3606687188148499) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2975804805755615) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.10966694355011) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7469146847724915) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { + if (averageDuration_2 <= -0.83043372631073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.7551783919334412) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3707275390625) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.905255436897278) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.966581106185913) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.830192446708679) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.8336945176124573) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (maxDuration_2 <= -0.6223993897438049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8229105472564697) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4624377489089966) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.1078864336013794) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8634464740753174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514787554741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6661685705184937) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4906747490167618) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2865267992019653) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.7411022186279297) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7496738731861115) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.394932746887207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.8827180564403534) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8706024289131165) { + if (averageDuration_2 <= -0.9420485198497772) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3730994313955307) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0538286566734314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5956095159053802) { + if (numDurations_2 <= 5.277176856994629) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (maxDuration_2 <= -0.8873393833637238) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (maxDuration_2 <= -0.8422902822494507) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.006060117069864646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3949337750673294) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6858274042606354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6824533343315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { + if (maxDuration_2 <= -0.5662876963615417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 13.529880046844482) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3579035997390747) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1557555198669434) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4892008304595947) { + if (maxDuration_2 <= -0.9147280156612396) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.0530831813812256) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7123874425888062) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.472243070602417) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8780922591686249) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45958754420280457) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.722435861825943) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2557140588760376) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5946207046508789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7728005051612854) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.9367633759975433) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (maxDuration_2 <= -0.893126517534256) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7746219038963318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.9004712700843811) { + if (averageDuration_2 <= -0.9028914868831635) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 6.415480613708496) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.916979730129242) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4398447275161743) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8584083318710327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.8117936849594116) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9524775743484497) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (averageDuration_2 <= -0.9899145066738129) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2896693348884583) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7897141575813293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4252666234970093) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4604972004890442) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9219915270805359) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + if (numDurations_2 <= -0.9834946841001511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0659967064857483) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.012343046255409718) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.15088313072919846) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8273943066596985) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5277437567710876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.430165648460388) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (averageDuration_2 <= -0.950395792722702) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -1.016234278678894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331878066063) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8056853115558624) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9506865739822388) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.6246561259031296) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5147928297519684) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9652901887893677) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.913651466369629) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33236296474933624) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2559059858322144) { + if (averageDuration_2 <= -0.9241907000541687) { + if (averageDuration_2 <= -0.9859334528446198) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (averageDuration_2 <= -1.0553088784217834) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8515954911708832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2347669005393982) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3299046456813812) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0757222175598145) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.013138234615326) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (maxDuration_2 <= -0.4580049514770508) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.9378644824028015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.565378785133362) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6371042132377625) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1215521693229675) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2026745080947876) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1562942266464233) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8788168132305145) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873018741608) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4027637541294098) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.828829526901245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0930700302124023) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.839429259300232) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.9521813690662384) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 6.130904674530029) { + if (maxDuration_2 <= -0.7244238257408142) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.3491384983062744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { + if (averageDuration_2 <= -0.9546661078929901) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188198328018) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6990544199943542) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.530005156993866) { + if (averageDuration_2 <= -0.9123550057411194) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.418988823890686) { + if (averageDuration_2 <= -1.0079702138900757) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.955012559890747) { + if (maxDuration_2 <= -0.5524489879608154) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7109135687351227) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8283106088638306) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2398509979248047) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8228965401649475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3267014026641846) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6532392501831055) { + if (numDurations_2 <= 4.4234490394592285) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.9237745702266693) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0757389068603516) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.89655339717865) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4581053256988525) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.450324833393097) { + if (averageDuration_2 <= -1.0267493724822998) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7243913412094116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4913182854652405) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.9169768691062927) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2284765243530273) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7040690779685974) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8225417733192444) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.97329181432724) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9806111454963684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615085124969482) { + if (maxDuration_2 <= -0.4947442561388016) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2741315364837646) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5986303687095642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7327274680137634) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4551565051078796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.9754125475883484) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3980958461761475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8206180334091187) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1535773053765297) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6357339024543762) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (maxDuration_2 <= -0.815540075302124) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3514859676361084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (averageDuration_2 <= -0.9065405130386353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1840259432792664) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.903745949268341) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6302811205387115) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8499744832515717) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.49466609954834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.15320611000061) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.9070146679878235) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.509147524833679) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.9997538626194) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.886861801147461) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606340527534485) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9521702229976654) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7850407958030701) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06687165051698685) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1571465134620667) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.8432158529758453) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5440351963043213) { + if (maxDuration_2 <= -0.7570678293704987) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4485859274864197) { + if (averageDuration_2 <= -0.8464416265487671) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.723693072795868) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7691256105899811) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5466059148311615) { + if (averageDuration_2 <= -0.7833032310009003) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5035655498504639) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + if (averageDuration_2 <= -0.8279664516448975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.538621187210083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5016209036111832) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332921743392944) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3666815757751465) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8741868734359741) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7355797290802002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7707876861095428) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6552789211273193) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9386163949966431) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.487790107727051) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8244539499282837) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7733666896820068) { + if (averageDuration_2 <= -0.7749311625957489) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.60456782579422) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.608403742313385) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8349080085754395) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1782058477401733) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6740623712539673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.6041640937328339) { + if (averageDuration_2 <= -0.7945300936698914) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7981260418891907) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6522490084171295) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (maxDuration_2 <= -0.81557297706604) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6447227001190186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4597684144973755) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8340048491954803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.7727617621421814) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7723895609378815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8788294792175293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7658993005752563) { + if (maxDuration_2 <= -0.5049230456352234) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7077453434467316) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8612527251243591) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.061204195022583) { + if (maxDuration_2 <= -0.5938813984394073) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6383099555969238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6345333456993103) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.632796049118042) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (numDurations_2 <= 9.545816898345947) { + if (maxDuration_2 <= -0.8716923594474792) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7087380290031433) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.8026283979415894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8646871745586395) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.493836522102356) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.320164144039154) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2675538063049316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 4.992600917816162) { + if (maxDuration_2 <= -0.8139824271202087) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0197227597236633) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.113975167274475) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5728220343589783) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= -0.6589663028717041) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.054711103439331) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.951200842857361) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10016503557562828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9293405413627625) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.3950346112251282) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4472568035125732) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (maxDuration_2 <= -0.7945745289325714) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2612701654434204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.931052565574646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8036738634109497) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4377331733703613) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.7592433094978333) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3983694911003113) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5586511194705963) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.06610369682312) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.110644102096558) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.805087387561798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9410525262355804) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1176055669784546) { + if (cpuCoreIdleTimesPercentage_3_2 <= -3.011645793914795) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7770498692989349) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7160633206367493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5224948823451996) { + if (maxDuration_2 <= -0.6990969479084015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4302920997142792) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4597282409667969) { + if (numDurations_2 <= 2.4314171075820923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3099656701087952) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3256698250770569) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (maxDuration_2 <= -0.36321648955345154) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4115738123655319) { + if (averageDuration_2 <= -0.8722012341022491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0242519676685333) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7829872071743011) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.800653338432312) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5957834422588348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4540817141532898) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7575851082801819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.042469322681427) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8718798756599426) { + if (maxDuration_2 <= -0.6845466196537018) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1571571826934814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9715858399868011) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18896040320396423) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20519939064979553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5486844778060913) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2478381991386414) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.7706505656242371) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8568443357944489) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.968813419342041) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6436975598335266) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.773976743221283) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6957504749298096) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (maxDuration_2 <= -0.7119098007678986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619667530059814) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7011626660823822) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461756706237793) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.8048639893531799) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (maxDuration_2 <= -0.688140481710434) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= -0.8446581363677979) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6684078276157379) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05320047400891781) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7287174463272095) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4778245687484741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0355538129806519) { + if (maxDuration_2 <= -0.5815573632717133) { + if (averageDuration_2 <= -0.7998105883598328) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.0901434333063662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6085982918739319) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5246248841285706) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.36999616026878357) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6384816765785217) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (maxDuration_2 <= -0.754046231508255) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (maxDuration_2 <= -0.7571184039115906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.756370484828949) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3127827644348145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.8134504854679108) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5593773126602173) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2623846307396889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.464223861694336) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.660483181476593) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32598327100276947) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38049089908599854) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5559250116348267) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5431971251964569) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.132140636444092) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7666589915752411) { + if (averageDuration_2 <= -0.8746799230575562) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.479934275150299) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (numDurations_2 <= 6.984632968902588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.2328837439417839) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379605531692505) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (maxDuration_2 <= -0.6834424138069153) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3280709385871887) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698965072632) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4637714624404907) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4629448056221008) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400545448064804) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8667867481708527) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8198107779026031) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9228427112102509) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7305030822753906) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.933671712875366) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8825189769268036) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.444722294807434) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.458875298500061) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7778335213661194) { + if (averageDuration_2 <= -0.8371435105800629) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33878976106643677) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3556060940027237) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.48610520362854004) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.757363885641098) { + if (maxDuration_2 <= -0.7965651154518127) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4627230763435364) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7627346515655518) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5679146647453308) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10755031183362007) { + if (maxDuration_2 <= -0.38182656466960907) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6295213997364044) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3013823628425598) { + if (averageDuration_2 <= -0.7429067492485046) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.9630446434020996) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6015337705612183) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.8719946444034576) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.093846917152405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 4.4234490394592285) { + if (maxDuration_2 <= -0.65662881731987) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9708781242370605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9306021332740784) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6256362199783325) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14081879705190659) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8647972941398621) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5280683040618896) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.540590688586235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.059429883956909) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9558411240577698) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6544794738292694) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.775170773267746) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6076676845550537) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8559397161006927) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.0406334400177) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6336471438407898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (numDurations_2 <= -0.9834946841001511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3683982938528061) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618817567825317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.8213829696178436) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862038612366) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9670726954936981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5489716231822968) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0583035349845886) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.7689407467842102) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (maxDuration_2 <= -0.6173821985721588) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1842116117477417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6446698904037476) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0076655745506287) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.7969815731048584) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.354353427886963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.721750855445862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1419968008995056) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.31924521923065186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.906386137008667) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.583980083465576) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8492881953716278) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.203004002571106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.563915252685547) { + if (averageDuration_2 <= -0.8613669872283936) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8993547558784485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.099716305732727) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (maxDuration_2 <= -0.6612307131290436) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3617601990699768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4203787446022034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9199471473693848) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0915238857269287) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2108792066574097) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.281714677810669) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619022607803345) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.232560396194458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.8123577237129211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.405747413635254) { + if (maxDuration_2 <= -0.8575548827648163) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.498576521873474) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8414876759052277) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0551009774208069) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9874106347560883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.01875431463122368) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2101417779922485) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9421150982379913) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539397239685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9589083194732666) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4446340799331665) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.803770899772644) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643927812576294) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7603563070297241) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7712722718715668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (maxDuration_2 <= -0.6897666156291962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9058563113212585) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1475949883460999) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3260526657104492) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.0093899965286255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (maxDuration_2 <= -0.8228392601013184) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3960390090942383) { + if (averageDuration_2 <= -0.5157813429832458) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.007528921356424689) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8359135687351227) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (averageDuration_2 <= -0.5456342995166779) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22983158379793167) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6392495036125183) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486260831356049) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485783398151398) { + if (maxDuration_2 <= -0.5975258648395538) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5927896797657013) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7853769659996033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6358963251113892) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.604397177696228) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.6920459866523743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0470258593559265) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7771201431751251) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.023341845721006393) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5546751320362091) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (maxDuration_2 <= -0.530951589345932) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.546684741973877) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9480875134468079) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9544385373592377) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.638963371515274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5272070169448853) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.46955904364585876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5369200110435486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0035837888717651) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6336411833763123) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6483595371246338) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6048111915588379) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.743807464838028) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0210902094841003) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6912557780742645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5500552952289581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606725335121) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (averageDuration_2 <= -0.5877749621868134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5824218392372131) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7400625646114349) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8532929420471191) { + if (maxDuration_2 <= -0.6454192101955414) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5994768440723419) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9038569331169128) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482589483261108) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7694981396198273) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8636158108711243) { + if (maxDuration_2 <= -0.628004252910614) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8737764954566956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6504161655902863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333688616752625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6712436676025391) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.884510725736618) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484709620475769) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.730811208486557) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485968470573425) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7819785177707672) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8385233581066132) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= -0.6964022219181061) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4698442667722702) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.952339768409729) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7374774813652039) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7550464570522308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6633287072181702) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8814240992069244) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7698891162872314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.61076620221138) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6701431572437286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485992610454559) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.320826455950737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3715362697839737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6787854433059692) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8597661256790161) { + if (averageDuration_2 <= -0.6796804666519165) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6905139684677124) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6075789928436279) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6899658143520355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.554974764585495) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40743666887283325) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6277902126312256) { + if (averageDuration_2 <= -0.6431439220905304) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17794623225927353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3609192669391632) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5069827735424042) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.31902356445789337) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.060293251648545265) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485435009002686) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4465062767267227) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6861523687839508) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6041235029697418) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748603343963623) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6483242511749268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5124680399894714) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12704207003116608) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + if (maxDuration_2 <= -0.4175705313682556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.591272622346878) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (averageDuration_2 <= -0.5772822797298431) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153710365295) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5332270860671997) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (maxDuration_2 <= -0.4324399530887604) { + if (averageDuration_2 <= -0.6844503879547119) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485789954662323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6816843748092651) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (maxDuration_2 <= -0.7213441133499146) { + if (averageDuration_2 <= -0.7046564817428589) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4334983825683594) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46484625339508057) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16997188329696655) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6630618572235107) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7191852927207947) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485575973987579) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20825889706611633) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (maxDuration_2 <= -0.6980890333652496) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536155462265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (averageDuration_2 <= -0.6949074864387512) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4904349148273468) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.7220077514648438) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (maxDuration_2 <= -0.6588171124458313) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4685062915086746) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7699243724346161) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733549669384956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5296683013439178) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6504805684089661) { + if (averageDuration_2 <= -0.6531988382339478) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8023247122764587) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6691294610500336) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4222228527069092) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748591959476471) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485432326793671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6177831590175629) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4125160872936249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107351958751678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6706370711326599) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4100015163421631) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (maxDuration_2 <= -0.711248904466629) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7185181379318237) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485837042331696) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748336672782898) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (averageDuration_2 <= -0.6261669099330902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (maxDuration_2 <= -0.7037317156791687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7192880809307098) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7047324776649475) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (maxDuration_2 <= -0.6842199563980103) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2714546322822571) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6771233975887299) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22378838062286377) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4285396933555603) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (averageDuration_2 <= -0.6054178774356842) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6675294637680054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4195016771554947) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936677023768425) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3724527508020401) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6110678315162659) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2513269782066345) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (averageDuration_2 <= -0.6188427209854126) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (maxDuration_2 <= -0.6951915919780731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (averageDuration_2 <= -0.6744060218334198) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6136997044086456) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6604484617710114) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6394027173519135) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (averageDuration_2 <= -0.6120813190937042) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748609870672226) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748603343963623) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7178165912628174) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.532955139875412) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6033738553524017) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6572758555412292) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3376786708831787) { + if (averageDuration_2 <= -0.5650409460067749) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.361456036567688) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48195189237594604) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23954086005687714) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2084840536117554) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6508654356002808) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (maxDuration_2 <= -0.5290368497371674) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21867432445287704) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (averageDuration_2 <= -0.6498101055622101) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748496949672699) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3376462757587433) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5041942000389099) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (averageDuration_2 <= -0.5611105561256409) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5205740034580231) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8000273108482361) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486188113689423) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5214121639728546) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (maxDuration_2 <= -0.6176987886428833) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (averageDuration_2 <= -0.6011090874671936) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4266907870769501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (averageDuration_2 <= -0.6032699346542358) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4068826586008072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4921558350324631) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41336560249328613) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484335899353027) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (maxDuration_2 <= -0.5634079277515411) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484835386276245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6128653585910797) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6249295771121979) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7576852440834045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6146012842655182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5974780023097992) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5316459834575653) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485824823379517) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23322559893131256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4946656823158264) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (averageDuration_2 <= -0.6335780322551727) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22531962394714355) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485611140727997) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485007643699646) { + if (maxDuration_2 <= -0.4611505717039108) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40549637377262115) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5104211270809174) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6547143757343292) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.532973974943161) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (maxDuration_2 <= -0.6466854214668274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5264957845211029) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7538074254989624) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5115297734737396) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3073139637708664) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (averageDuration_2 <= -0.5249474942684174) { + if (maxDuration_2 <= -0.5617717802524567) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5655190050601959) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485272586345673) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485611140727997) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4673936665058136) { + if (maxDuration_2 <= -0.6263783574104309) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5324617028236389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486114799976349) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481594085693359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5590387880802155) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.6375018954277039) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4305918663740158) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6507574915885925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2645939588546753) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48034144937992096) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6957877278327942) { + if (averageDuration_2 <= -0.660845160484314) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488866329193) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5284946858882904) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4532432556152344) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5421792566776276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6566312313079834) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354000866413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2642674148082733) { + if (maxDuration_2 <= -0.5991974771022797) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5389397144317627) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1849617063999176) { + if (maxDuration_2 <= -0.572259783744812) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5639564692974091) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5945397615432739) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.405854269862175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5394801497459412) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6324848234653473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6987986862659454) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (averageDuration_2 <= -0.6675359606742859) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7475108206272125) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5995874404907227) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6970761120319366) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5134455561637878) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04597241245210171) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.790956050157547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485424280166626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7650184333324432) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04997594468295574) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7010264098644257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.7021442651748657) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.4015178084373474) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1397358924150467) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (averageDuration_2 <= -0.6868498623371124) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485724985599518) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5936229825019836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6456277966499329) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5782218277454376) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6147219240665436) { + if (maxDuration_2 <= -0.6379780471324921) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05733483098447323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.643456220626831) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6731904745101929) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08903738111257553) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (averageDuration_2 <= -0.6119145154953003) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6230626702308655) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8424716889858246) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847400546074) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (averageDuration_2 <= -0.6104327440261841) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.007084414828568697) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855878829956) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841269969940186) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6444239318370819) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6172641515731812) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5662826299667358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.3652705103158951) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27553869783878326) { + if (numDurations_2 <= 3.2851450443267822) { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.5692499876022339) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5977484285831451) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7318758368492126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160940885544) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 0.439385250210762) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6304270625114441) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5489367246627808) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.694299191236496) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10667318850755692) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08962436020374298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= -0.20087847113609314) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5218600034713745) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5698562264442444) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7082695364952087) { + if (averageDuration_2 <= -0.6612632572650909) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (averageDuration_2 <= -0.6955849230289459) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6525955498218536) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21691525727510452) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04798941686749458) { + if (maxDuration_2 <= -0.6930412948131561) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517697870731354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (averageDuration_2 <= -0.6839952170848846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (averageDuration_2 <= -0.6835059821605682) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18038693815469742) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6536406576633453) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2356841340661049) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (averageDuration_2 <= -0.7137193977832794) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6812206208705902) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485706210136414) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (averageDuration_2 <= -0.7054987847805023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733549669384956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2445385828614235) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842179775238) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139989942312241) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (maxDuration_2 <= -0.4572376310825348) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11027532815933228) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748517245054245) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34279532730579376) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (maxDuration_2 <= -0.38142649829387665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0253522926941514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6834248900413513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484937012195587) { + if (averageDuration_2 <= -0.631439208984375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5090310871601105) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6039360761642456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6352212727069855) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (averageDuration_2 <= -0.6671374440193176) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6866046786308289) { + if (averageDuration_2 <= -0.6149443089962006) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6944897174835205) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5411479473114014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6286375820636749) { + if (maxDuration_2 <= -0.6716552376747131) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4215746968984604) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.0423296093940735) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.026302258484065533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46510113775730133) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5988070070743561) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.042329579591751) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.668794721364975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6424522995948792) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.64404296875) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.7656015157699585) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5453222990036011) { + if (averageDuration_2 <= -0.5461871922016144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (maxDuration_2 <= -0.585097998380661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.027122885920107365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (maxDuration_2 <= -0.6191018521785736) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6282239556312561) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07829613238573074) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6878625154495239) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.40787293016910553) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.22422988712787628) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5374608933925629) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.588569164276123) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06822561100125313) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5781760513782501) { + if (maxDuration_2 <= -0.4789426326751709) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.300174742937088) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485353648662567) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (averageDuration_2 <= -0.5880172848701477) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.002244919538498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6295723915100098) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485992610454559) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.6921901702880859) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4419638216495514) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8675388097763062) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5713100731372833) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.6195882260799408) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1996062621474266) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (maxDuration_2 <= -0.22818096727132797) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6852182149887085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6514990925788879) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322981834412) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5804727673530579) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899798870087) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404849529266) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213215112686) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7619152665138245) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (averageDuration_2 <= -0.5452398657798767) { + if (maxDuration_2 <= -0.6641103625297546) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.34787847101688385) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6154486835002899) { + if (averageDuration_2 <= -0.5607624053955078) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4662224352359772) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6752177774906158) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319651782512665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492305755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11068692803382874) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6383446455001831) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9217394888401031) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6941938102245331) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9093784391880035) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.42492644488811493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23459776490926743) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6046440899372101) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43739528954029083) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20044124871492386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.05957953445613384) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2924148291349411) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45932169258594513) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0871067643165588) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7840979397296906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47124210000038147) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5237013697624207) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5342198610305786) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (maxDuration_2 <= -0.6540328860282898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8714148998260498) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.34762173891067505) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5263397395610809) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7476334869861603) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8368437886238098) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5359322726726532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6760017573833466) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5618625581264496) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7643071413040161) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6155336499214172) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6422670781612396) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5969028472900391) { + if (averageDuration_2 <= -0.6759653985500336) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47244781255722046) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5369020104408264) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.41351819038391113) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45444560050964355) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484953105449677) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.770579993724823) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838244438171) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6042501926422119) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5863262712955475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5210910439491272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (averageDuration_2 <= -0.7150693535804749) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.519459456205368) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.39651884138584137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481858432292938) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (averageDuration_2 <= -0.6015669405460358) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3505530059337616) { + if (maxDuration_2 <= -0.5795058608055115) { + if (maxDuration_2 <= -0.7217139005661011) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40935175120830536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6024494171142578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5781534910202026) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4069344401359558) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5657877922058105) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.610083132982254) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.638565331697464) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14634910970926285) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.626937210559845) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28022557497024536) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13262738287448883) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5639826357364655) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6744546592235565) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1899980828166008) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.552857905626297) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414793252945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2463686391711235) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4980434477329254) { + if (averageDuration_2 <= -0.627543568611145) { + if (averageDuration_2 <= -0.7154621779918671) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5412898659706116) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7993462979793549) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485218644142151) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= -0.689498096704483) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5480370819568634) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4083185940980911) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4732617288827896) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6083711385726929) { + if (maxDuration_2 <= -0.6663544178009033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40701262652873993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08822394162416458) { + if (maxDuration_2 <= -0.4295426160097122) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08839131146669388) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403679728507996) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5407092273235321) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5203063786029816) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31380872428417206) { + if (averageDuration_2 <= -0.5786982774734497) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2984289079904556) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781625390052795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12949947267770767) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (numDurations_2 <= 1.0085371732711792) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2446230947971344) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2851778566837311) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (maxDuration_2 <= -0.6765104532241821) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5222593545913696) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6917480528354645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7582287192344666) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5823552459478378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999027848243713) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0802515149116516) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5017153173685074) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.0423296093940735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5403911769390106) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5186237692832947) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.535802811384201) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4796397536993027) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.757517397403717) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11604801192879677) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49329011142253876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.005905506433919072) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14113952219486237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (maxDuration_2 <= -0.5534570813179016) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7893184721469879) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6546649634838104) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8972694575786591) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6686395704746246) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7807700037956238) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8067096173763275) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (averageDuration_2 <= -0.517570823431015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (maxDuration_2 <= -0.7105295062065125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (averageDuration_2 <= -0.6506192982196808) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7193965315818787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7479998171329498) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.020146310795098543) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16618554294109344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6064302027225494) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5101828575134277) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.667258620262146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8032214045524597) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.047010223381221294) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6012665331363678) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1896573901176453) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.523535817861557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5769451558589935) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3540363758802414) { + if (maxDuration_2 <= -0.6117343008518219) { + if (averageDuration_2 <= -0.6909461617469788) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (averageDuration_2 <= -0.6851257085800171) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6393543183803558) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0009598145261406898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310733318329) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7961551249027252) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.5917007327079773) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.5429995954036713) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5616816878318787) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5549914836883545) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485779225826263) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (maxDuration_2 <= -0.6409969329833984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5662066042423248) { + if (averageDuration_2 <= -0.5878584980964661) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.526660829782486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.56511589884758) { + if (maxDuration_2 <= -0.6013149619102478) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2638162672519684) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5930226743221283) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.606551855802536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5235054194927216) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.607789933681488) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33874310553073883) { + if (maxDuration_2 <= -0.5596063733100891) { + if (averageDuration_2 <= -0.598783940076828) { + if (maxDuration_2 <= -0.6287640333175659) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5687431395053864) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (averageDuration_2 <= -0.6792748272418976) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6913191676139832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6528525054454803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6040748357772827) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5514818131923676) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5849686861038208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7389303743839264) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9167837500572205) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (averageDuration_2 <= -0.5778533816337585) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (averageDuration_2 <= -0.5858899354934692) { + if (maxDuration_2 <= -0.5800730586051941) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6351085603237152) { + if (averageDuration_2 <= -0.5561364591121674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6997388601303101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.6096473336219788) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5562358200550079) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5649585723876953) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4618343561887741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8643427491188049) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7363891005516052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.47486500442028046) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485738694667816) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5422701239585876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5866097211837769) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5356996059417725) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6189756095409393) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20948798209428787) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17552682384848595) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2627904862165451) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46973055601119995) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3995477110147476) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4549883306026459) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4470599740743637) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.081233449280262) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5141535997390747) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40597008168697357) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5840265452861786) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5293951034545898) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748531848192215) { + if (averageDuration_2 <= -0.5975858867168427) { + if (maxDuration_2 <= -0.6773234009742737) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7233274579048157) { + if (averageDuration_2 <= -0.5371653437614441) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43006590008735657) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35924243927001953) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5309438407421112) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49216729402542114) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5913253426551819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5325217843055725) { + if (averageDuration_2 <= -0.5971518456935883) { + if (maxDuration_2 <= -0.5827095806598663) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4056427478790283) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27833035588264465) { + if (maxDuration_2 <= -0.6454672515392303) { + if (averageDuration_2 <= -0.6022332906723022) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (averageDuration_2 <= -0.6186088025569916) { + if (maxDuration_2 <= -0.6766547858715057) { + if (averageDuration_2 <= -0.6437556147575378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41131511330604553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5364763289690018) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6195144653320312) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49299095571041107) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6415844857692719) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6260719299316406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4396364092826843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48652738332748413) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (maxDuration_2 <= -0.6298075914382935) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4331739842891693) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478503584861755) { + if (maxDuration_2 <= -0.5732856392860413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5805055797100067) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485036849975586) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5585563480854034) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (maxDuration_2 <= -0.5671309232711792) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.585450142621994) { + if (averageDuration_2 <= -0.5500621795654297) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5785264074802399) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= -0.5830569267272949) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485168278217316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5522496700286865) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (maxDuration_2 <= -0.41487836837768555) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6467221975326538) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5366165935993195) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (maxDuration_2 <= -0.4236970692873001) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6700685620307922) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8278171420097351) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2507883459329605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5487158894538879) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.514430820941925) { + if (averageDuration_2 <= -0.5451783239841461) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (averageDuration_2 <= -0.5507667660713196) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44435377418994904) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5573250651359558) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1838471032679081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.596017450094223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5346470773220062) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8750398457050323) { + if (numDurations_2 <= -0.6989187151193619) { + if (maxDuration_2 <= -0.22777052223682404) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.972898542881012) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5845165550708771) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.399220049381256) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6483140885829926) { + if (averageDuration_2 <= -0.6634586155414581) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6414876878261566) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5942731201648712) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2129421830177307) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7056423723697662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2873587608337402) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6307599544525146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5706699192523956) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0856215953826904) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.767348438501358) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9372516572475433) { + if (maxDuration_2 <= -0.6185142993927002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9083563983440399) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7598126232624054) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (maxDuration_2 <= -0.5063439011573792) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (averageDuration_2 <= -0.5468631684780121) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9630212187767029) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196251034736633) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6257500648498535) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6275864839553833) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8962610960006714) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485578656196594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + if (maxDuration_2 <= -0.14342425018548965) { + if (numDurations_2 <= 0.43938523530960083) { + if (maxDuration_2 <= -0.21614809334278107) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794910855591297) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7120539247989655) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6087577939033508) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (maxDuration_2 <= -0.682690292596817) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4900243580341339) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9355016946792603) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (maxDuration_2 <= -0.4319891929626465) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (averageDuration_2 <= -0.5210753977298737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (averageDuration_2 <= -0.585249125957489) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8006477653980255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0362975001335144) { + if (averageDuration_2 <= -0.5741309523582458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5659933388233185) { + if (averageDuration_2 <= -0.7179114520549774) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5983854234218597) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6374053657054901) { + if (averageDuration_2 <= -0.520757406949997) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4125160872936249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9024714231491089) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6655683517456055) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.41851530969142914) { + if (maxDuration_2 <= -0.726186603307724) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6629176735877991) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.4389185607433319) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= -0.5597861707210541) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5338271260261536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5414673388004303) { + if (averageDuration_2 <= -0.6014557182788849) { + if (averageDuration_2 <= -0.6624838709831238) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6941531598567963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7770487666130066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9014868140220642) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7702146768569946) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6734192073345184) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.743566632270813) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5177218914031982) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8021135926246643) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7406646609306335) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7139269709587097) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7505207359790802) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7699485719203949) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (maxDuration_2 <= -0.6585537493228912) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9031726717948914) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6200547516345978) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4592435210943222) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484660744667053) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485881745815277) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8960750997066498) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8728941977024078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6590854525566101) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (averageDuration_2 <= -0.610890656709671) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6037259697914124) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.552806168794632) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6184648275375366) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6293505430221558) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40446633100509644) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6927808225154877) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.2328837439417839) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43991389870643616) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6491851210594177) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5502419471740723) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6018134653568268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748531848192215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= -0.6191984713077545) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5861019790172577) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6626396477222443) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6078225374221802) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.576707124710083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5866127014160156) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7098152935504913) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485046684741974) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.520365834236145) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5643603205680847) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7258638441562653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.740404486656189) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485131919384003) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5550532639026642) { + if (maxDuration_2 <= -0.6149559915065765) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (averageDuration_2 <= -0.5808843076229095) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6322320103645325) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (maxDuration_2 <= -0.5984604358673096) { + if (averageDuration_2 <= -0.5512113869190216) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485862672328949) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= -0.597943514585495) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6107260584831238) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (averageDuration_2 <= -0.5599744915962219) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.2714780643582344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49900294840335846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5330140292644501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485817074775696) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5982114970684052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5790416300296783) { + if (averageDuration_2 <= -0.5644314885139465) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6182861328125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6995039582252502) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5764604806900024) { + if (maxDuration_2 <= -0.605121374130249) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7591287791728973) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4939318895339966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6701739728450775) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6028318107128143) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.532272607088089) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6183344423770905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41205063462257385) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153114318848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (maxDuration_2 <= -0.4491785317659378) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (averageDuration_2 <= -0.5576899647712708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6411390900611877) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485213279724121) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6526772081851959) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (averageDuration_2 <= -0.6330696642398834) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5661900639533997) { + if (averageDuration_2 <= -0.5864149928092957) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (averageDuration_2 <= -0.556185781955719) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485407888889313) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8572129905223846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3921169638633728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6735976934432983) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4611380845308304) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5642342269420624) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6537365913391113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349805697799) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (maxDuration_2 <= -0.44838833808898926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6914373338222504) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (averageDuration_2 <= -0.5469672679901123) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5165861546993256) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5911261439323425) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7472980916500092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34113065898418427) { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= -0.7495760023593903) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8090662956237793) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.23433195054531097) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6742688417434692) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.00141179561615) { + if (numDurations_2 <= 1.008537232875824) { + if (numDurations_2 <= -0.12976674735546112) { + if (maxDuration_2 <= -0.5126476734876633) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6859812140464783) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.061686933040619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6398320496082306) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0598382949829102) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7172970473766327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0345925092697144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6395599246025085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5678352415561676) { + if (averageDuration_2 <= -0.605718731880188) { + if (maxDuration_2 <= -0.6316083371639252) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (averageDuration_2 <= -0.6518807709217072) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40861111879348755) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6253732442855835) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (maxDuration_2 <= -0.6536909341812134) { + if (averageDuration_2 <= -0.6893901526927948) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42184053361415863) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5066401958465576) { + if (maxDuration_2 <= -0.7556417882442474) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.498565211892128) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.42411546409130096) { + if (averageDuration_2 <= -0.6865964829921722) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.6445934474468231) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49230001866817474) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5398352146148682) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (averageDuration_2 <= -0.6477979123592377) { + if (maxDuration_2 <= -0.7091670334339142) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5645840764045715) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6981422305107117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6272600889205933) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (averageDuration_2 <= -0.7003393471240997) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41999803483486176) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.061789870262146) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3741445541381836) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (averageDuration_2 <= -0.6289122998714447) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5422446727752686) { + if (maxDuration_2 <= -0.6622742712497711) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6440703868865967) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41004645824432373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5421479642391205) { + if (averageDuration_2 <= -0.6175379157066345) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6597008109092712) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35844261944293976) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5029757618904114) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6421452164649963) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5787990689277649) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4371054023504257) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (maxDuration_2 <= -0.6162703335285187) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5757979452610016) { + if (maxDuration_2 <= -0.5782268643379211) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5214055180549622) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5368035733699799) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40317757427692413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6583429574966431) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (maxDuration_2 <= -0.6474706828594208) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4809093326330185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.785048633813858) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5809987187385559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41081346571445465) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5946136116981506) { + if (maxDuration_2 <= -0.6137528121471405) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485660016536713) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6585428714752197) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6874723732471466) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5693450272083282) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5880981981754303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44632408022880554) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.594263881444931) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4079017639160156) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1967049166560173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5264497101306915) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.5458243489265442) { + if (maxDuration_2 <= -0.5993368029594421) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481858432292938) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5868915021419525) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49191422760486603) { + if (maxDuration_2 <= -0.5460184216499329) { + if (averageDuration_2 <= -0.5909486413002014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5095407962799072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5338984727859497) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.39174215495586395) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (averageDuration_2 <= -0.6353524327278137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74856898188591) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5755828320980072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5242930352687836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5580313205718994) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5027727484703064) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47908376157283783) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485332489013672) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.18612299859523773) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.48679912090301514) { + if (maxDuration_2 <= -0.5508838891983032) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47643306851387024) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486082315444946) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.061824679374694824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48094354569911957) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40606094896793365) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5451184511184692) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4485495835542679) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5079343616962433) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.459091380238533) { + if (maxDuration_2 <= -0.5443013310432434) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (maxDuration_2 <= -0.7598031461238861) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7475833892822266) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (averageDuration_2 <= -0.7109265625476837) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4185460954904556) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5985917150974274) { + if (maxDuration_2 <= -0.3784303367137909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5767474174499512) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (averageDuration_2 <= -0.5898222625255585) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10193079710006714) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19134365767240524) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.650122344493866) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28140027821063995) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.383526086807251) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4492497593164444) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08315486088395119) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4633228927850723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (averageDuration_2 <= -0.6963796317577362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17047882080078125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2071799710392952) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5255636870861053) { + if (maxDuration_2 <= -0.5394283831119537) { + if (averageDuration_2 <= -0.6123175024986267) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.511682540178299) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485400140285492) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485432326793671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5043495297431946) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.633042961359024) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6224579513072968) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206787645817) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (averageDuration_2 <= -0.6095631718635559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6031866371631622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172387123108) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4012703001499176) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8568866550922394) { + if (maxDuration_2 <= -0.6382971704006195) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484807074069977) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5110880434513092) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33234161138534546) { + if (averageDuration_2 <= -0.6279172599315643) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48621073365211487) { + if (maxDuration_2 <= -0.6418150663375854) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5762304663658142) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35096926987171173) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9410466551780701) { + if (numDurations_2 <= 1.2931131720542908) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6238240599632263) { + if (averageDuration_2 <= -0.6304374039173126) { + if (averageDuration_2 <= -0.6305539309978485) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1005992889404297) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0994991064071655) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5841317474842072) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6542835533618927) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5831116437911987) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9211200475692749) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0981878638267517) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (numDurations_2 <= -1.2680706679821014) { + if (averageDuration_2 <= -0.5648576617240906) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14984966069459915) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0574679374694824) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965908551588655) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9750412702560425) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.15082854684442282) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7469054460525513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7356725037097931) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6677635610103607) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9177530109882355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5682734847068787) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9457249045372009) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6293622553348541) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6325351297855377) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5895840227603912) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0103041529655457) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9852869808673859) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485602796077728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6489087641239166) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8934656977653503) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7098634541034698) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.036111831665039) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485472857952118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9295522570610046) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5339083969593048) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0688284635543823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7776155769824982) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6109642684459686) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (averageDuration_2 <= -0.5401910245418549) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7403310239315033) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9199309349060059) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5308011174201965) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842068016529) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0337629318237305) { + if (averageDuration_2 <= -0.7030116021633148) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5017267167568207) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (maxDuration_2 <= -0.5441063046455383) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4029839485883713) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9040396511554718) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6129928827285767) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9740192592144012) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1211307048797607) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5457411110401154) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485465109348297) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5942600071430206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9761590659618378) { + if (maxDuration_2 <= -0.45941825211048126) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 0.439385250210762) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (maxDuration_2 <= -0.5178372859954834) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5744504630565643) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5607343018054962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5259328782558441) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8766833245754242) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20753058046102524) { + if (maxDuration_2 <= -0.4275569021701813) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5871747434139252) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5413225889205933) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42498302459716797) { + if (maxDuration_2 <= -0.1784287393093109) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01564949657768011) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6168189346790314) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6790743172168732) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5551392734050751) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6783662736415863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5899710655212402) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.579148679971695) { + if (averageDuration_2 <= -0.6760516464710236) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5288830995559692) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (averageDuration_2 <= -0.5701581537723541) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + if (maxDuration_2 <= -0.5195874273777008) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5353161990642548) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (averageDuration_2 <= -0.5475077629089355) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.621362954378128) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5792880952358246) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10758400056511164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3468835949897766) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6633188426494598) { + if (maxDuration_2 <= -0.4614797681570053) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3089700937271118) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (maxDuration_2 <= -0.6612407565116882) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3300398290157318) { + if (maxDuration_2 <= -0.49757328629493713) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15521842241287231) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485578656196594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5470214486122131) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12778066843748093) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37474068999290466) { + if (averageDuration_2 <= -0.5727451741695404) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44540999829769135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4799879491329193) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5575012266635895) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5254124999046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4052685499191284) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + if (averageDuration_2 <= -0.5327414274215698) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40609219670295715) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6149024367332458) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (maxDuration_2 <= -0.6303115785121918) { + if (averageDuration_2 <= -0.6150277256965637) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6403545141220093) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2544964998960495) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5272620618343353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5343095660209656) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31468772888183594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 0.43938517570495605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.34311598539352417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04233570955693722) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.09231467545032501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7452520728111267) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.8238902390003204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396401524543762) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8508541285991669) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3640372157096863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (averageDuration_2 <= -0.6898009181022644) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2542356848716736) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6032586395740509) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.8184602558612823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6101516485214233) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13585316389799118) { + if (averageDuration_2 <= -0.6986209750175476) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.325019896030426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4068748503923416) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.6047946810722351) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6055684387683868) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34697169065475464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6567239463329315) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.038201725110411644) { + if (averageDuration_2 <= -0.7078695595264435) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.45547060668468475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6924512386322021) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.554705798625946) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2668192833662033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6001040041446686) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4804098457098007) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.048951586708426476) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= -0.7167750597000122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5858961641788483) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (maxDuration_2 <= -0.6378109753131866) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5424762666225433) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4065143018960953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5802216231822968) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6085640490055084) { + if (maxDuration_2 <= -0.7004444301128387) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7362076938152313) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5702382326126099) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3191536068916321) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748468279838562) { + if (maxDuration_2 <= -0.5911916792392731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48627130687236786) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7426013946533203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6676006019115448) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7244588136672974) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5432488024234772) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5292292237281799) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.588408425450325) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (averageDuration_2 <= -0.5283207595348358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5599989295005798) { + if (maxDuration_2 <= -0.576337456703186) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5747544467449188) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5682758092880249) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486014664173126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485822141170502) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5735616087913513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5616148710250854) { + if (averageDuration_2 <= -0.601123034954071) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32193659245967865) { + if (maxDuration_2 <= -0.6446897685527802) { + if (averageDuration_2 <= -0.6165066957473755) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8131964206695557) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.70070019364357) { + if (averageDuration_2 <= -0.6616089344024658) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4859745353460312) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.644880473613739) { + if (averageDuration_2 <= -0.6873809695243835) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6631074547767639) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6133298575878143) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (averageDuration_2 <= -0.6042291522026062) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44035471975803375) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6700165867805481) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44464975595474243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5581760108470917) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6289109289646149) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5403825044631958) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5714545845985413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6713647842407227) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5491890609264374) { + if (maxDuration_2 <= -0.619600772857666) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6781724691390991) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40903517603874207) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.6256894767284393) { + if (maxDuration_2 <= -0.6465968191623688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.5807237327098846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4406105577945709) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04633626714348793) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5676531195640564) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484703958034515) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.45388931035995483) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5068480670452118) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5819621384143829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5245867073535919) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5854982137680054) { + if (maxDuration_2 <= -0.6158956289291382) { + if (averageDuration_2 <= -0.618424117565155) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.042526408564299345) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12119465321302414) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4471616744995117) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5848534405231476) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31118519604206085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6401105225086212) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7203609049320221) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5040415525436401) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8468363583087921) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.024465138092637062) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.18479663133621216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4730672836303711) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4553234577178955) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5851899683475494) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6681893169879913) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7882016897201538) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3109428733587265) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (averageDuration_2 <= -0.6290301084518433) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (maxDuration_2 <= -0.7581214606761932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (averageDuration_2 <= -0.7083679437637329) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4910467863082886) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8535929024219513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5749009251594543) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12006822228431702) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484993636608124) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6496344804763794) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (maxDuration_2 <= -0.7137130796909332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4290008693933487) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.502291738986969) { + if (averageDuration_2 <= -0.7152606546878815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7135182917118073) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7803255617618561) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6566592454910278) { + if (averageDuration_2 <= -0.6294673979282379) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.559353768825531) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4586620181798935) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5487784445285797) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8971228301525116) { + if (maxDuration_2 <= -0.7519009411334991) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3090042918920517) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7480176985263824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.735450953245163) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (averageDuration_2 <= -0.6348683536052704) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5965524017810822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.52269446849823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5557147562503815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31765952706336975) { + if (maxDuration_2 <= -0.6758417785167694) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6530837714672089) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46255192160606384) { + if (maxDuration_2 <= -0.7342659533023834) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6724081337451935) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5124752521514893) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6895538568496704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7037407457828522) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49726374447345734) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484878599643707) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44689221680164337) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.31357966363430023) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484384477138519) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6448163986206055) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5043505430221558) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6094005405902863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.620573103427887) { + if (averageDuration_2 <= -0.7007867693901062) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5457299947738647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6447851359844208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (maxDuration_2 <= -0.715828001499176) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.184060700237751) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23817872256040573) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.6290706396102905) { + if (maxDuration_2 <= -0.7308543622493744) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6547055542469025) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485988736152649) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7353141903877258) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6454848647117615) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5412477850914001) { + if (averageDuration_2 <= -0.5934551358222961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5178772509098053) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39365823566913605) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.76400426030159) { + if (averageDuration_2 <= -0.6174235939979553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6081715524196625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748590350151062) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5016510188579559) { + if (maxDuration_2 <= -0.6520800292491913) { + if (maxDuration_2 <= -0.6585866510868073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5579375922679901) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7149111032485962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5994527637958527) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10048868134617805) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4595942944288254) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4744039326906204) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (maxDuration_2 <= -0.6280599534511566) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5274279117584229) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43255744874477386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6205936670303345) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47046665847301483) { + if (maxDuration_2 <= -0.2748406231403351) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6053260266780853) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6008701026439667) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22330547124147415) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6061720848083496) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43165072798728943) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (maxDuration_2 <= -0.5724497139453888) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8727467060089111) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.515039712190628) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6484903991222382) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6078263521194458) { + if (averageDuration_2 <= -0.622720867395401) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19340523332357407) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5759347677230835) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (maxDuration_2 <= -0.5912752449512482) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6705639064311981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38828402757644653) { + if (averageDuration_2 <= -0.6015032827854156) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5773809254169464) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4022064357995987) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6693777441978455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6506822407245636) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486122846603394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6147647202014923) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6135873198509216) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.654521107673645) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4159712791442871) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5367083847522736) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6667650938034058) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21927902102470398) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4579868018627167) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.66371750831604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6333103179931641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485212981700897) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748604953289032) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6182128190994263) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (maxDuration_2 <= -0.5866580903530121) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5502391755580902) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6393870711326599) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7099716067314148) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486003637313843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6417466700077057) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6366530060768127) { + if (maxDuration_2 <= -0.608241617679596) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4293956160545349) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5718539357185364) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40134064853191376) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6216707229614258) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.713463544845581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.513492077589035) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5331782698631287) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6629994213581085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6264947950839996) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4017510265111923) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6832115352153778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5383094549179077) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6058141887187958) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (maxDuration_2 <= -0.6113214790821075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (maxDuration_2 <= -0.6155282557010651) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47968408465385437) { + if (averageDuration_2 <= -0.5728826224803925) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5770086050033569) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9917370676994324) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5146026313304901) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5330525636672974) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5107685923576355) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40300559997558594) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5584996342658997) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5423844158649445) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (averageDuration_2 <= -0.5568572282791138) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638475418091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5662193596363068) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7420831322669983) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9386163949966431) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6286956667900085) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (maxDuration_2 <= -0.6660833954811096) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485785782337189) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5398869812488556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5224565863609314) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (maxDuration_2 <= -0.5859920382499695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6133907437324524) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6859308779239655) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6380309760570526) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6397914290428162) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6532373130321503) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5714013576507568) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5694357454776764) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5583223104476929) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5707395970821381) { + if (maxDuration_2 <= -0.6094370782375336) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6915875673294067) { + if (averageDuration_2 <= -0.5813417434692383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5518341362476349) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5493275821208954) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8231029808521271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5616311430931091) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486079931259155) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6204337477684021) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.581122100353241) { + if (averageDuration_2 <= -0.5817528665065765) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5857867896556854) { + if (averageDuration_2 <= -0.5835716128349304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5786197185516357) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4693758487701416) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6720173954963684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5457231998443604) { + if (maxDuration_2 <= -0.5849308669567108) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5526072978973389) { + if (maxDuration_2 <= -0.6069222390651703) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6370143890380859) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5708008408546448) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485783100128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40665461868047714) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5405711233615875) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4807713031768799) { + if (averageDuration_2 <= -0.5496420860290527) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5044622421264648) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (averageDuration_2 <= -0.5701306462287903) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6795294284820557) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (averageDuration_2 <= -0.5370084345340729) { + if (averageDuration_2 <= -0.5404379665851593) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5220567882061005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44767098128795624) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484880089759827) { + if (averageDuration_2 <= -0.5527431964874268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (maxDuration_2 <= -0.6434739828109741) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9179660081863403) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1523250341415405) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7255125045776367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6893866956233978) { + if (maxDuration_2 <= -0.8133594691753387) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36309659481048584) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6731290519237518) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486057877540588) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6867575943470001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.7307353019714355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7828660309314728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15674817562103271) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8120512962341309) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12434348464012146) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42685945332050323) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748557060956955) { + if (maxDuration_2 <= -0.7677456140518188) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14801420271396637) { + if (averageDuration_2 <= -0.5637625455856323) { + if (averageDuration_2 <= -0.7082066237926483) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.7201589345932007) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.2328837439417839) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7369267344474792) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9049053490161896) { + if (maxDuration_2 <= -0.20259317755699158) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3468298316001892) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6966659724712372) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (maxDuration_2 <= -0.6178127527236938) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74850994348526) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (maxDuration_2 <= -0.20296283066272736) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8983940780162811) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5048615634441376) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2180181741714478) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5492505431175232) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403679728507996) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42564503848552704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10248609259724617) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5433846414089203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9222651720046997) { + if (numDurations_2 <= 1.008537232875824) { + if (averageDuration_2 <= -0.6975576281547546) { + if (maxDuration_2 <= -0.6935478150844574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.590107798576355) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6772269904613495) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6784807443618774) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0474528670310974) { + if (averageDuration_2 <= -0.6112178266048431) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40660393238067627) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3825113922357559) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.627986490726471) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6279688477516174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5605310201644897) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6281616985797882) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6496928334236145) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0098888874053955) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.683344155550003) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4462507665157318) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4000002592802048) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8399596810340881) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.2877315431833267) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (averageDuration_2 <= -0.34540486335754395) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7017553150653839) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9205435514450073) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19148658961057663) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0940665006637573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13630641996860504) { + if (averageDuration_2 <= -0.35186243057250977) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.2410571128129959) { + if (averageDuration_2 <= -0.3510347306728363) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.49503903090953827) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333688616752625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.4461781978607178) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.37599845230579376) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7415765225887299) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.47954896092414856) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.642632395029068) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (averageDuration_2 <= -0.4210948646068573) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.44387005269527435) { + if (averageDuration_2 <= -0.48302602767944336) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7935082018375397) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7152048349380493) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291666150093079) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.43829044699668884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8891547918319702) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7404561340808868) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (averageDuration_2 <= -0.41596120595932007) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8743529617786407) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.4564676433801651) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4851799011230469) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (maxDuration_2 <= -0.5305514335632324) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4358919858932495) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3944251388311386) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17146595567464828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4069526493549347) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8995382487773895) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11026938259601593) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3778313398361206) { + if (averageDuration_2 <= -0.494231253862381) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49228665232658386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5896517336368561) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30096161365509033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.37698450684547424) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4443999081850052) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (averageDuration_2 <= -0.4630194902420044) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.38063959777355194) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.47397103905677795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.59116330742836) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (maxDuration_2 <= -0.5003565847873688) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7525697350502014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (maxDuration_2 <= -0.5653911530971527) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5609693825244904) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (averageDuration_2 <= -0.4999157041311264) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48056595027446747) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.42769622802734375) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (averageDuration_2 <= -0.4851462095975876) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.1860547438263893) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.503919243812561) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7661499083042145) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4706431180238724) { + if (maxDuration_2 <= -0.48763492703437805) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20744965970516205) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.47474098205566406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17529451102018356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21807967126369476) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149006992578506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3601253926753998) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04249554127454758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7162122130393982) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.35286179184913635) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.31029582023620605) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06011745519936085) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3663276731967926) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1259683407843113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (maxDuration_2 <= -0.2410849779844284) { + if (averageDuration_2 <= -0.34614574909210205) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28263644874095917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.626276284456253) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6430130004882812) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8410999476909637) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2552844136953354) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9045834839344025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5827533602714539) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (maxDuration_2 <= -0.4003532975912094) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7266887128353119) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4546778202056885) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9977320432662964) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4583968222141266) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.528881847858429) { + if (maxDuration_2 <= -0.39596420526504517) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3688119053840637) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.46508629620075226) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4043523669242859) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6036120057106018) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5994037836790085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3829658776521683) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5149401277303696) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6164318025112152) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7718425691127777) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.48109008371829987) { + if (averageDuration_2 <= -0.5132443308830261) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4969526380300522) { + if (maxDuration_2 <= -0.5544624924659729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.4267718493938446) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49063943326473236) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0057587623596191) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (averageDuration_2 <= -0.38895364105701447) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9100799858570099) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (maxDuration_2 <= -0.4638276696205139) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.4844638705253601) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07414579764008522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15412722527980804) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (maxDuration_2 <= -0.579267680644989) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.3726997375488281) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (averageDuration_2 <= -0.4388546645641327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7991330921649933) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.43590258061885834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7464483678340912) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5735138654708862) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.767071932554245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.723993718624115) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (averageDuration_2 <= -0.493863046169281) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748504251241684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7409085631370544) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.729773759841919) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7778133451938629) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485854625701904) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.517627090215683) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310733318329) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4762718379497528) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.46599817276000977) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.377871572971344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5336331725120544) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2204464077949524) { + if (averageDuration_2 <= -0.4575706869363785) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.3670579642057419) { + if (maxDuration_2 <= -0.5299789607524872) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3480940908193588) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.40196920931339264) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32685886323451996) { + if (averageDuration_2 <= -0.41820454597473145) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888539791107) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.33038510382175446) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.36887556314468384) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2201223149895668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4013080447912216) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485660016536713) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2026185691356659) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8007532954216003) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2664951980113983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.3851279765367508) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.743062436580658) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.751629501581192) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748591423034668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3785570114850998) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485180795192719) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.010079063475131989) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.36808939278125763) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239316046238) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (averageDuration_2 <= -0.4779582768678665) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.35226769745349884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.26787397265434265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4233684539794922) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (averageDuration_2 <= -0.5028457939624786) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.49016015231609344) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46725763380527496) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5059376657009125) { + if (maxDuration_2 <= -0.6131221652030945) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5076574981212616) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1585126891732216) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9132877290248871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.37163498997688293) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3141997307538986) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21854796260595322) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09460854530334473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.40125441551208496) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6049173176288605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4752926826477051) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9213506281375885) { + if (averageDuration_2 <= -0.426745668053627) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.055704932659864426) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5342630743980408) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337137460708618) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.48006628453731537) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.012840613257139921) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (averageDuration_2 <= -0.45031706988811493) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4091905653476715) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7835126519203186) { + if (maxDuration_2 <= -0.4653852581977844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10502529516816139) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2845323234796524) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16484689712524414) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6682112514972687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4631006270647049) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.41155287623405457) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03138184733688831) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5259695649147034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10861397534608841) { + if (averageDuration_2 <= -0.39306725561618805) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.39124275743961334) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.08298928290605545) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406549453735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7777889370918274) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (averageDuration_2 <= -0.3684269189834595) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10438846424221992) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (averageDuration_2 <= -0.3936549574136734) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.362395241856575) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7681441307067871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093146696686745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13112079352140427) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3652183711528778) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2574236989021301) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.33562271296977997) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118843227625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.660483181476593) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.506536453962326) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.32608775794506073) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (maxDuration_2 <= -0.4119150638580322) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44431379437446594) { + if (averageDuration_2 <= -0.34741465747356415) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776627898216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3507463037967682) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.362347275018692) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7093702256679535) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (averageDuration_2 <= -0.4503464996814728) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2983732968568802) { + if (maxDuration_2 <= -0.4048260301351547) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6632714867591858) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (maxDuration_2 <= -0.45629797875881195) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4836314022541046) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5747091472148895) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748517245054245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5038794577121735) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (maxDuration_2 <= -0.42466969788074493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1396324560046196) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6700529158115387) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.47315068542957306) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07969395071268082) { + if (averageDuration_2 <= -0.44210630655288696) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41178272664546967) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40749040246009827) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3706723004579544) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.50300532579422) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.40446610748767853) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (maxDuration_2 <= -0.46705421805381775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4970572739839554) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.35793112218379974) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.308582067489624) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41950754821300507) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48391093313694) { + if (maxDuration_2 <= -0.2743797153234482) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03685928788036108) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5232345759868622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.454201802611351) { + if (averageDuration_2 <= -0.3931693285703659) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484807074069977) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4952777624130249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.41781623661518097) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (averageDuration_2 <= -0.37019820511341095) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4875843822956085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.3727445602416992) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.560415506362915) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5791451930999756) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (averageDuration_2 <= -0.42943713068962097) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18633536249399185) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.41728562116622925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485789656639099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4269566982984543) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3023456037044525) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16437020152807236) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4807608276605606) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (averageDuration_2 <= -0.45464618504047394) { + if (maxDuration_2 <= -0.4271947890520096) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3698868006467819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (numDurations_2 <= 0.7239612340927124) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1557164490222931) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41612885892391205) { + if (averageDuration_2 <= -0.40913572907447815) { + if (maxDuration_2 <= -0.4529648423194885) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1408619061112404) { + if (averageDuration_2 <= -0.4314831793308258) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45960503816604614) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3762267678976059) { + if (maxDuration_2 <= -0.504226490855217) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6010940968990326) { + if (maxDuration_2 <= -0.3172658085823059) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (averageDuration_2 <= -0.4017970561981201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4419882595539093) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5142407417297363) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7865826189517975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4972071796655655) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6212486326694489) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4103454202413559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7480404376983643) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6729304194450378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.39219117164611816) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4125809222459793) { + if (maxDuration_2 <= -0.42406441271305084) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4642833173274994) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5679060518741608) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04718700051307678) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29762402176856995) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (averageDuration_2 <= -0.501738578081131) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485513687133789) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.49111516773700714) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (averageDuration_2 <= -0.42941662669181824) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5418379604816437) { + if (averageDuration_2 <= -0.4747678190469742) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5410770773887634) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32124680280685425) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726021289825) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (averageDuration_2 <= -0.4440923184156418) { + if (maxDuration_2 <= -0.5019851177930832) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4398898780345917) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081358909606934) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.49508771300315857) { + if (maxDuration_2 <= -0.48788562417030334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4896344691514969) { + if (averageDuration_2 <= -0.4507438540458679) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41779862344264984) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5499401986598969) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.570503443479538) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43093550205230713) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.25616973638534546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.24880194664001465) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03453083150088787) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7461006939411163) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4127431809902191) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45739488303661346) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22403627634048462) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (averageDuration_2 <= -0.36030514538288116) { + if (maxDuration_2 <= -0.3840097486972809) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17149866372346878) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43955984711647034) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3870605528354645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43470507860183716) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3862901031970978) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46103645861148834) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41658972203731537) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22293802350759506) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6304048895835876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21000273525714874) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.2663256376981735) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.719666987657547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2784240245819092) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485543489456177) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484888434410095) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20849379897117615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5191213488578796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4678848683834076) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5091754198074341) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41808490455150604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485456764698029) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (maxDuration_2 <= -0.2799491658806801) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.39570824801921844) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.056119196116924286) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6769475638866425) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.47905300557613373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5281854569911957) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44329987466335297) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5711765885353088) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (averageDuration_2 <= -0.4733972102403641) { + if (averageDuration_2 <= -0.5068470537662506) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6933205425739288) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4892762154340744) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4130202829837799) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3620969206094742) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16565268486738205) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5786398351192474) { + if (averageDuration_2 <= -0.45893630385398865) { + if (maxDuration_2 <= -0.5071670413017273) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.25047922134399414) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2493586465716362) { + if (averageDuration_2 <= -0.4554085284471512) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (maxDuration_2 <= -0.46151284873485565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4036356508731842) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3999886214733124) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6674900352954865) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.13103439658880234) { + if (averageDuration_2 <= -0.43849073350429535) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5540191829204559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.179450161755085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4265744686126709) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4285469055175781) { + if (maxDuration_2 <= -0.39530307054519653) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18543855100870132) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5626822113990784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49787428975105286) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.040106117725372314) { + if (maxDuration_2 <= -0.15610798448324203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6746149063110352) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4630049765110016) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47228793799877167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2534039169549942) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.46695293486118317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29987315833568573) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736397743225) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10769771784543991) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5740419030189514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.424423485994339) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5884684920310974) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44160230457782745) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6087464392185211) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12730631977319717) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4946414828300476) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6059083044528961) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6941799521446228) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5457775890827179) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1150943897664547) { + if (averageDuration_2 <= -0.44752050936222076) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2644287645816803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4905020147562027) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.41398613154888153) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4533536732196808) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4850296974182129) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.419027179479599) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6164864003658295) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0031615342013537884) { + if (maxDuration_2 <= -0.4362060874700546) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.45395445823669434) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0016115749604068696) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.328902930021286) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.691698431968689) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16084719449281693) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4556976854801178) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3992614150047302) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5179385542869568) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0943399928510189) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.15231416374444962) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5621752440929413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.44039031863212585) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3822551816701889) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5433201491832733) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49638791382312775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3995536118745804) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4145127087831497) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.19224528968334198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.49668678641319275) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.018273180350661278) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4519044905900955) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6990666389465332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8132957518100739) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20161471515893936) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03642451763153076) { + if (averageDuration_2 <= -0.4608576148748398) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4528513550758362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4229937791824341) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4202948212623596) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1469392403960228) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4582834839820862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4660760760307312) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4944300204515457) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15142468363046646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09841525554656982) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.244485005736351) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43423469364643097) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.46017545461654663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4411269873380661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (maxDuration_2 <= -0.49218378961086273) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48566870391368866) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48042768239974976) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1080469973385334) { + if (averageDuration_2 <= -0.3567211478948593) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.10004199296236038) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10565562918782234) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.37569865584373474) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5894407033920288) { + if (averageDuration_2 <= -0.36318132281303406) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5873809158802032) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16533751785755157) { + if (maxDuration_2 <= -0.3092878609895706) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18742173165082932) { + if (averageDuration_2 <= -0.37049008905887604) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.44659511744976044) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.39335623383522034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.025132120586931705) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5923017263412476) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5148386359214783) { + if (averageDuration_2 <= -0.3809855282306671) { + if (maxDuration_2 <= -0.507296234369278) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.0901434333063662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29907163977622986) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1446518450975418) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456615447998) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2874078154563904) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3512396067380905) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5290227234363556) { + if (maxDuration_2 <= -0.32623156905174255) { + if (averageDuration_2 <= -0.3565983325242996) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.18799541145563126) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6498253643512726) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07784419879317284) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08636709302663803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4425090402364731) { + if (averageDuration_2 <= -0.3749467134475708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.35074035823345184) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (maxDuration_2 <= -0.43764713406562805) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.49329546093940735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3715676963329315) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4230690002441406) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (maxDuration_2 <= -0.4030809551477432) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (maxDuration_2 <= -0.4536639153957367) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4366084486246109) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.477387934923172) { + if (averageDuration_2 <= -0.3590942770242691) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988372206688) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3570324778556824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6008574962615967) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5154628753662109) { + if (averageDuration_2 <= -0.38761185109615326) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5854571461677551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5360842049121857) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03509561903774738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9909244477748871) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03151668608188629) { + if (maxDuration_2 <= -0.2715330123901367) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02706373669207096) { + if (averageDuration_2 <= -0.3614296019077301) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16825183480978012) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39569199085235596) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2941809594631195) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6344625651836395) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3932870477437973) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.40227964520454407) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.17791948467493057) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485261857509613) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6551596224308014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7208743691444397) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0558820962905884) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485139966011047) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6419090330600739) { + if (averageDuration_2 <= -0.31675757467746735) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485635578632355) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3034067302942276) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.31897203624248505) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4765326827764511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7427478432655334) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5333503186702728) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.11648909747600555) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0708580911159515) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485418915748596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5631608963012695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5322364568710327) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1978984847664833) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5630575120449066) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5175121128559113) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (averageDuration_2 <= -0.3178412914276123) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.45541906356811523) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3104892373085022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8331855833530426) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8101078569889069) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2878285348415375) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (averageDuration_2 <= -0.3147650808095932) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3570113182067871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2747475504875183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.3326541930437088) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.16981247812509537) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.54273521900177) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (averageDuration_2 <= -0.3024888038635254) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.30293726921081543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2529370039701462) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.46095047891139984) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6099193692207336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4858836680650711) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4537171572446823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0038877129554749) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6403085887432098) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6276201903820038) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2991176098585129) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7371344268321991) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (averageDuration_2 <= -0.2939274162054062) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7419174313545227) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5942821502685547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.424275666475296) { + if (maxDuration_2 <= -0.42066293954849243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.405598521232605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.11151490360498428) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.989253968000412) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486149966716766) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7367870509624481) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6408440172672272) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4892643690109253) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3139950782060623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.30552856624126434) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30460232496261597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4172285199165344) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.2964763939380646) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.33606092631816864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.32926855981349945) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6817446649074554) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (numDurations_2 <= -0.1297668218612671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7583528161048889) { + if (averageDuration_2 <= -0.31135936081409454) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1614174246788025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3746485263109207) { + if (averageDuration_2 <= -0.2896265983581543) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715816631913185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3067418336868286) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.47083306312561035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (maxDuration_2 <= -0.4128117561340332) { + if (averageDuration_2 <= -0.3376539796590805) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3031547963619232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08689345419406891) { + if (averageDuration_2 <= -0.3356188088655472) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.1591067910194397) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (averageDuration_2 <= -0.29920725524425507) { + if (maxDuration_2 <= -0.39796750247478485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (averageDuration_2 <= -0.31926129758358) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01973761059343815) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4675256758928299) { + if (averageDuration_2 <= -0.3103250414133072) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9929423928260803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7352018058300018) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748537540435791) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485678493976593) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1456533595919609) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5935258269309998) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15680913627147675) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04596349410712719) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (maxDuration_2 <= -0.41855818033218384) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6563375890254974) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485968470573425) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514787554741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.01346769742667675) { + if (maxDuration_2 <= -0.390498548746109) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7949601709842682) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3154606819152832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.3287476897239685) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08151774853467941) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.2979160398244858) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (maxDuration_2 <= -0.47105082869529724) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7183324992656708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12416355311870575) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (maxDuration_2 <= -0.3431219011545181) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748530238866806) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665165930986404) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6495566666126251) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12215658277273178) { + if (maxDuration_2 <= -0.20833201706409454) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6435374021530151) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.19842172414064407) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06969590112566948) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6412895619869232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4883332848548889) { + if (averageDuration_2 <= -0.29506683349609375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.212310314178467) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7431512773036957) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.30452634394168854) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541325807571) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.11537477001547813) { + if (averageDuration_2 <= -0.3168568015098572) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (averageDuration_2 <= -0.294744148850441) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (maxDuration_2 <= -0.24545379728078842) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7378760874271393) { + if (maxDuration_2 <= -0.23839524388313293) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5999282002449036) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.000891057075932622) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30530960857868195) { + if (maxDuration_2 <= -0.08422767743468285) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48441511392593384) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486155331134796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7405452132225037) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04867475852370262) { + if (maxDuration_2 <= -0.2602396756410599) { + if (averageDuration_2 <= -0.3177509903907776) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3514444977045059) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4628470093011856) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6669897437095642) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02586555667221546) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485204935073853) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.710762083530426) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.2888945937156677) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (averageDuration_2 <= -0.305282860994339) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485489249229431) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.719666987657547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.17324932664632797) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6049166917800903) { + if (averageDuration_2 <= -0.3115391433238983) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486082315444946) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13514093309640884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (maxDuration_2 <= -0.41962702572345734) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.3243833929300308) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6832435131072998) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (averageDuration_2 <= -0.3391868770122528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.048756638541817665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26047728955745697) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7389938533306122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01992938807234168) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.33988627791404724) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06831160560250282) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5779412984848022) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5477691292762756) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236781001091003) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3719669282436371) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.039831243455410004) { + if (maxDuration_2 <= -0.3972887396812439) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3438810557126999) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.17679756879806519) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16015350818634033) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06850844621658325) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6106472909450531) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6635494530200958) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.19382239133119583) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48690031468868256) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (maxDuration_2 <= -0.3190765976905823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= -0.2309415638446808) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4887588322162628) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.31096629798412323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8531287908554077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.2700489014387131) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.020650038495659828) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.23226115852594376) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (maxDuration_2 <= -0.369667187333107) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6987103223800659) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.679982990026474) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15833443403244019) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.471129834651947) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.570559561252594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.41398029029369354) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.806976318359375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7733803391456604) { + if (averageDuration_2 <= -0.30801011621952057) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04985160194337368) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14670702069997787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4666711539030075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4428822845220566) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4138956069946289) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6050992608070374) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.14580752700567245) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.589937150478363) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.047017522156238556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24539043009281158) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3288295269012451) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4168309271335602) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3191639333963394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.2211880311369896) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (averageDuration_2 <= -0.3153810650110245) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (maxDuration_2 <= -0.35830044746398926) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36085793375968933) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4964791536331177) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.2671917825937271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.29083825647830963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8840866684913635) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6136572062969208) { + if (averageDuration_2 <= -0.28967784345149994) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.030796382576227188) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3483317494392395) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3091466873884201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14336030930280685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= -0.35937391221523285) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6205548942089081) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6732939183712006) { + if (averageDuration_2 <= -0.4557391107082367) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7463884353637695) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6468529999256134) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (maxDuration_2 <= -0.21173348277807236) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485678791999817) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5472673177719116) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.971582442522049) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5858054459095001) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (averageDuration_2 <= -0.47994987666606903) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.952353447675705) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.460571750998497) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08236062154173851) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (maxDuration_2 <= -0.3703991025686264) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6926728188991547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23677273094654083) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3147457093000412) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.227210633456707) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6073647737503052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484758198261261) { + if (averageDuration_2 <= -0.5047189593315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423399567604065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1794150397181511) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (averageDuration_2 <= -0.3914089798927307) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1175682544708252) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.511399120092392) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.158347338438034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.0093110501766205) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32184144854545593) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.539190262556076) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4547124058008194) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29165515303611755) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2970457226037979) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6735343337059021) { + if (averageDuration_2 <= -0.3668102025985718) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9637999832630157) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (averageDuration_2 <= -0.44082432985305786) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8328611850738525) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35350100696086884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2541857808828354) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7281917333602905) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.42982448637485504) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.40536922216415405) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.044920265674591) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4267992824316025) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.039008972235023975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (averageDuration_2 <= -0.3647245615720749) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (maxDuration_2 <= -0.5160163044929504) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7280016839504242) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06783053651452065) { + if (maxDuration_2 <= -0.42021968960762024) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2712238281965256) { + if (averageDuration_2 <= -0.3818550556898117) { + if (averageDuration_2 <= -0.48794177174568176) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3879541605710983) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5329106748104095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (maxDuration_2 <= -0.5539103746414185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6946929693222046) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8001738786697388) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.38631975650787354) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08192503079771996) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5768885910511017) { + if (averageDuration_2 <= -0.46969887614250183) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6494906842708588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4711901843547821) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5981233716011047) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.04522705078125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08277841657400131) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2993634045124054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29814137518405914) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08189302682876587) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9323183596134186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.008361813146620989) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15882298350334167) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8310829102993011) { + if (averageDuration_2 <= -0.45987817645072937) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5259695649147034) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5050472319126129) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08293446153402328) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.40526340901851654) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4066242426633835) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.045778799802064896) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.266085147857666) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8231558501720428) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3941274881362915) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07360317558050156) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1819828748703003) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11521785706281662) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7521063089370728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9121025502681732) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19483810663223267) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1911996677517891) { + if (averageDuration_2 <= -0.3635105937719345) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.36061790585517883) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07640846818685532) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3654271066188812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.4280431866645813) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5619236528873444) { + if (averageDuration_2 <= -0.3775222599506378) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30325064063072205) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144360721111298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01783779449760914) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.51244255900383) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1637340635061264) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1384930983185768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6465511620044708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7116492390632629) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6551260054111481) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09770984947681427) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.4501853287220001) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (averageDuration_2 <= -0.38718122243881226) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07085730880498886) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32217201590538025) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (averageDuration_2 <= -0.4106654226779938) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5457653105258942) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07920760661363602) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3914494663476944) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184718966484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23218537867069244) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8112705945968628) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6908784508705139) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33865055441856384) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4726920872926712) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.49287670850753784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5137620866298676) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32959793508052826) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (maxDuration_2 <= -0.5481662452220917) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4073130637407303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3660598695278168) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3646329939365387) { + if (averageDuration_2 <= -0.43427373468875885) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6094579696655273) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4963194876909256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47894246876239777) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47688962519168854) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7437491118907928) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.39237380027770996) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06641573272645473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18190962821245193) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5667342245578766) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.38016390800476074) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74592524766922) { + if (averageDuration_2 <= -0.47020673751831055) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7462577223777771) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.39919283986091614) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.42137348651885986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48538437485694885) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48207370936870575) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09140275791287422) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5791686177253723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4318486154079437) { + if (averageDuration_2 <= -0.3897954672574997) { + if (maxDuration_2 <= -0.33242902159690857) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.36858421564102173) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07693177089095116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5931233167648315) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.024488925002515316) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48469358682632446) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.45206885039806366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47563140094280243) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2744697332382202) { + if (maxDuration_2 <= -0.5989924371242523) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (averageDuration_2 <= -0.3656543046236038) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.40201225876808167) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5942909717559814) { + if (averageDuration_2 <= -0.43314817547798157) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (averageDuration_2 <= -0.5060972273349762) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.42785969376564026) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3176281005144119) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5466181039810181) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5164822936058044) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09725334867835045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.011714194901287556) { + if (averageDuration_2 <= -0.5017145276069641) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (averageDuration_2 <= -0.43901774287223816) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6961819529533386) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4974755644798279) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03696174267679453) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.42411841452121735) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24362723529338837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29506441950798035) { + if (averageDuration_2 <= -0.4380848854780197) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (averageDuration_2 <= -0.44128017127513885) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7207963466644287) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7471691071987152) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30674906075000763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.43663278222084045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12104194611310959) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4108966141939163) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6597457826137543) { + if (averageDuration_2 <= -0.46600283682346344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2028055191040039) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.405785396695137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49180084466934204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.477101594209671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.4355500042438507) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.389234334230423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46072281897068024) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47018684446811676) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45189976692199707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.019049725495278835) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11203369870781898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2854778319597244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4394821673631668) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5636525750160217) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.734325647354126) { + if (maxDuration_2 <= -0.5053053796291351) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06428303010761738) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485359311103821) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3740568459033966) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4259895086288452) { + if (averageDuration_2 <= -0.5106721222400665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26141680777072906) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4689476490020752) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6905945241451263) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486049830913544) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (averageDuration_2 <= -0.4547649025917053) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10743620991706848) { + if (maxDuration_2 <= -0.33012424409389496) { + if (averageDuration_2 <= -0.49963298439979553) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4403581768274307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7425623834133148) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (maxDuration_2 <= -0.36448031663894653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.35043902695178986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (maxDuration_2 <= -0.11821127310395241) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748622864484787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4109240174293518) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47685542702674866) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46037299931049347) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0887279137969017) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5697632133960724) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4549849182367325) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7168501317501068) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3712909519672394) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5530483722686768) { + if (maxDuration_2 <= -0.38523824512958527) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5726436972618103) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.4643188714981079) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.456339955329895) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3300284445285797) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11841470375657082) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19587627053260803) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5362854897975922) { + if (maxDuration_2 <= -0.41052715480327606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03906398080289364) { + if (averageDuration_2 <= -0.40963590145111084) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3908051401376724) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5523447692394257) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.4104207903146744) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3719923794269562) { + if (maxDuration_2 <= -0.38130737841129303) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.49276863038539886) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1857169196009636) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.34520843625068665) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43344974517822266) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7438471615314484) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0953757762908936) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6379465162754059) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3294961154460907) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0948266983032227) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7104938924312592) { + if (maxDuration_2 <= -0.4453643262386322) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6514590382575989) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7597685754299164) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.610610157251358) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= -0.3061417043209076) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2548815459012985) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4000978320837021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.29631587862968445) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.29435835778713226) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.007171630859375) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3644263595342636) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2360130473971367) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.53001868724823) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2973712980747223) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9434346258640289) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.060656189918518) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4316839426755905) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7305657267570496) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4427632838487625) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21020342409610748) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (averageDuration_2 <= -0.33378028869628906) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4564969390630722) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (maxDuration_2 <= -0.25433603674173355) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23887929320335388) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9699702560901642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4313230663537979) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45885269343852997) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20277021080255508) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6792775392532349) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.12048579379916191) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0735624432563782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38062185049057007) { + if (averageDuration_2 <= -0.31052224338054657) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.2258281484246254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5330982506275177) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484611868858337) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.3201896995306015) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30082476139068604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5611414611339569) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9217639267444611) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.29752521216869354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.32565318048000336) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.020805480889976025) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1896788254380226) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3502329885959625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26303599774837494) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6895642578601837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15303920209407806) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10928329825401306) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.32107996940612793) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3334406763315201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37980569899082184) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25732724368572235) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9114156365394592) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6553419530391693) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.3304867595434189) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4831969439983368) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2888488173484802) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0011512195924296975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (averageDuration_2 <= -0.3473919481039047) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6014033854007721) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4405665844678879) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0034555174643173814) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22445404529571533) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5546018779277802) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.35571321845054626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5957482159137726) { + if (averageDuration_2 <= -0.33295397460460663) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09477000683546066) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (maxDuration_2 <= -0.19607143104076385) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.261422798037529) { + if (maxDuration_2 <= -0.44513383507728577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7814852297306061) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.640639990568161) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (averageDuration_2 <= -0.3160882741212845) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486155331134796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (maxDuration_2 <= -0.1554674133658409) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (averageDuration_2 <= -0.2909882962703705) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7041383981704712) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07533213868737221) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.30124498903751373) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.060450464487075806) { + if (maxDuration_2 <= -0.37136659026145935) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8414077162742615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.18656859546899796) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20904050767421722) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4641064554452896) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6243166923522949) { + if (averageDuration_2 <= -0.2971619814634323) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.026461328379809856) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9270704686641693) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.32033687829971313) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.31018005311489105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.38068194687366486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8721916675567627) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.026462645269930363) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16709522902965546) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.2588973939418793) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (maxDuration_2 <= -0.3104604631662369) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300742030143738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.30370788276195526) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.2924126982688904) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.522097259759903) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06071360036730766) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.35397788882255554) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.31898725032806396) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6958546936511993) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748256504535675) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486123144626617) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03280009888112545) { + if (averageDuration_2 <= -0.33573997020721436) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49064502120018005) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.34419097006320953) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02211772743612528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.417383149266243) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7827769219875336) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21714510023593903) { + if (maxDuration_2 <= -0.178725004196167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (averageDuration_2 <= -0.3312353640794754) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (maxDuration_2 <= -0.3506186902523041) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4309518188238144) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7372922599315643) { + if (maxDuration_2 <= -0.3793648034334183) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9375555515289307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02954611461609602) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (averageDuration_2 <= -0.3216385245323181) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0897640734910965) { + if (maxDuration_2 <= -0.49159595370292664) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06401299126446247) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.33471575379371643) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.011142936069518328) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1073484979569912) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (maxDuration_2 <= -0.17785881459712982) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5872890949249268) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1717079058289528) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6689273118972778) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.055434899404644966) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (maxDuration_2 <= -0.49465303122997284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (averageDuration_2 <= -0.32559140026569366) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.646384060382843) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6380632519721985) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6697246134281158) { + if (averageDuration_2 <= -0.34251372516155243) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.42763808369636536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.462016761302948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.32818686962127686) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.46072521805763245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26792269945144653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4107401967048645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6580115556716919) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7571949660778046) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (averageDuration_2 <= -0.2955334335565567) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1668855994939804) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8255780041217804) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15925020724534988) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5745860934257507) { + if (maxDuration_2 <= -0.39554373919963837) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06109306775033474) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.267517626285553) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6169191598892212) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.27511419355869293) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6796722710132599) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.308965727686882) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12848735973238945) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32213953137397766) { + if (averageDuration_2 <= -0.3138471096754074) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7774899303913116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44896169006824493) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47041742503643036) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (maxDuration_2 <= -0.3643232136964798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.29769130051136017) { + if (maxDuration_2 <= -0.3245902508497238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.3099205642938614) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6199217438697815) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1351606249809265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26406416296958923) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7266464829444885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5135562717914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7541288733482361) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21551334857940674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08976732194423676) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.12879037857055664) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3639540523290634) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5702849924564362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1932036578655243) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (maxDuration_2 <= -0.3252209275960922) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4855744391679764) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.31115463376045227) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4212530106306076) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3831788897514343) { + if (maxDuration_2 <= -0.4980189651250839) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.38811175525188446) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485432326793671) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4841309189796448) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3175671845674515) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7972817122936249) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5010329633951187) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.32494740188121796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7551675140857697) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2579679489135742) { + if (averageDuration_2 <= -0.3078204393386841) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20732781291007996) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.727687805891037) { + if (averageDuration_2 <= -0.4446764439344406) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7411335706710815) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (averageDuration_2 <= -0.48013298213481903) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.38501784205436707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5840363502502441) { + if (averageDuration_2 <= -0.5102361440658569) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4191809296607971) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42589758336544037) { + if (maxDuration_2 <= -0.48572011291980743) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0902109146118164) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.545682430267334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.030746312346309423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4856390506029129) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6191723346710205) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7405544221401215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8067652583122253) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4708937853574753) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (averageDuration_2 <= -0.3135262131690979) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28266243636608124) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.056200893595814705) { + if (maxDuration_2 <= -0.536351203918457) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7699341475963593) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3981545567512512) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46658407151699066) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49416443705558777) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45945559442043304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485738694667816) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26713743805885315) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7241617441177368) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2999030500650406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4944087117910385) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8442182540893555) { + if (averageDuration_2 <= -0.4250757396221161) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.4104030579328537) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.459503173828125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4907570630311966) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (maxDuration_2 <= -0.6040298044681549) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10847101360559464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6918887495994568) { + if (averageDuration_2 <= -0.2892002910375595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3735290765762329) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5970370173454285) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5067297518253326) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44272398948669434) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.46869537234306335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.45012809336185455) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5800626873970032) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.157261312007904) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26816023886203766) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3236072510480881) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07564329728484154) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4020204544067383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24450450390577316) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3675512820482254) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (averageDuration_2 <= -0.29318319261074066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (averageDuration_2 <= -0.30290183424949646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.32844461500644684) { + if (maxDuration_2 <= -0.23552051186561584) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05308774672448635) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (averageDuration_2 <= -0.3037213087081909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4804832637310028) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (maxDuration_2 <= -0.3744261711835861) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5363812297582626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.2818055599927902) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8277158737182617) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4904833436012268) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.32459279894828796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5802454054355621) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5212530493736267) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7138456404209137) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= -0.4826563149690628) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0176811814308167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5664218962192535) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3452174961566925) { + if (averageDuration_2 <= -0.4808720201253891) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8575237095355988) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (maxDuration_2 <= -0.36384451389312744) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5294224619865417) { + if (averageDuration_2 <= -0.3788570910692215) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4290819764137268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6521439552307129) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3031439334154129) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6052127778530121) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4961499273777008) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.39636632800102234) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5425024926662445) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5810853540897369) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.3469972759485245) { + if (maxDuration_2 <= -0.24029217660427094) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4592728316783905) { + if (averageDuration_2 <= -0.5005058348178864) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8092304468154907) { + if (maxDuration_2 <= -0.527317076921463) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7166167199611664) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3805789053440094) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6507578194141388) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35893769562244415) { + if (maxDuration_2 <= -0.594104140996933) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.2328837439417839) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.194828562438488) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.91253662109375) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4518558830022812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17103000730276108) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20013290643692017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (maxDuration_2 <= -0.3199402987957001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45828890800476074) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (numDurations_2 <= 1.0085371732711792) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11844425648450851) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27587294578552246) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09959760308265686) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (averageDuration_2 <= -0.3067745715379715) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.267594538629055) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3165307939052582) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4616197943687439) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3550025224685669) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.1510351076722145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.338320329785347) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4088563770055771) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744978427887) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6156865954399109) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4463558793067932) { + if (maxDuration_2 <= -0.27000077068805695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4716603457927704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48630382120609283) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4204797148704529) { + if (averageDuration_2 <= -0.3731165826320648) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.31107212603092194) { + if (maxDuration_2 <= -0.3498057425022125) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6655000150203705) { + if (averageDuration_2 <= -0.36327970027923584) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936677023768425) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03568781167268753) { + if (averageDuration_2 <= -0.48907576501369476) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486096024513245) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9567630290985107) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6882989406585693) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118889793754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5082663297653198) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (averageDuration_2 <= -0.4896525889635086) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.535529226064682) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.405038520693779) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.06424967106431723) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7282001078128815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5797421634197235) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07364777103066444) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.393616259098053) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748550534248352) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + if (averageDuration_2 <= -0.3177209049463272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8015496134757996) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4485579580068588) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3585778623819351) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.26351524889469147) { + if (averageDuration_2 <= -0.3358721137046814) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4646168649196625) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44904083013534546) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (averageDuration_2 <= -0.48851965367794037) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7481491267681122) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1491454839706421) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3289659768342972) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29460790753364563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5138256549835205) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (averageDuration_2 <= -0.3546811640262604) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2024102360010147) { + if (averageDuration_2 <= -0.36064085364341736) { + if (averageDuration_2 <= -0.36549951136112213) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25586676597595215) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7963813841342926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.41663283109664917) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.4326551556587219) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7583918869495392) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.43871140480041504) { + if (maxDuration_2 <= -0.43243739008903503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.022922703996300697) { + if (averageDuration_2 <= -0.4344189763069153) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.41698041558265686) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.661494642496109) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5528627932071686) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744438856840134) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6463684141635895) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.22502101957798004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5253871083259583) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8002188205718994) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6037119626998901) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8733290135860443) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4058011472225189) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08079643547534943) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815161705017) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4528794288635254) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7382297813892365) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03130711615085602) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.40464988350868225) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4296058267354965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (averageDuration_2 <= -0.3516629785299301) { + if (maxDuration_2 <= -0.35057583451271057) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19273536652326584) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12834439426660538) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.48990415036678314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8676228225231171) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.671675831079483) { + if (averageDuration_2 <= -0.3513958752155304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4221218228340149) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.031407841481268406) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.39286914467811584) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41435506939888) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.503915011882782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.49696534872055054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.016497523058205843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.39258554577827454) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6679727137088776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08481725305318832) { + if (averageDuration_2 <= -0.36943840980529785) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6755871176719666) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06551247090101242) { + if (averageDuration_2 <= -0.4933241456747055) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0739621818065643) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8722561299800873) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8938936293125153) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34456442296504974) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8541332185268402) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.45699694752693176) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46248646080493927) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6582233607769012) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.015414451248943806) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.41264815628528595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (averageDuration_2 <= -0.4358626455068588) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18886860460042953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4593397378921509) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2171775922179222) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02553339023143053) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47780922055244446) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (maxDuration_2 <= -0.4877311885356903) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.47117750346660614) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6400006711483002) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620310544968) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14982610195875168) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7159679532051086) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2705480009317398) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.32305124402046204) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09423814341425896) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.591503232717514) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08014403656125069) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.05986323952674866) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6973955929279327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14222664386034012) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.35748493671417236) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5794715285301208) { + if (maxDuration_2 <= -0.3650399148464203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.415433794260025) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6254217326641083) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (maxDuration_2 <= -0.4546845853328705) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0022142911329865456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7573903799057007) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6550918221473694) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.41428808867931366) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.31242114305496216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5713098049163818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4011714905500412) { + if (averageDuration_2 <= -0.32468704879283905) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3699488788843155) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7611453235149384) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.45118187367916107) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (averageDuration_2 <= -0.3809977173805237) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (maxDuration_2 <= -0.47351764142513275) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47201691567897797) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5223143696784973) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0726829431951046) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40178413689136505) { + if (averageDuration_2 <= -0.47677844762802124) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3474990874528885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.40035396814346313) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5768094062805176) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.42250923812389374) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (maxDuration_2 <= -0.4103929400444031) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4224357008934021) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7363114655017853) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6289030909538269) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6421366930007935) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7592478096485138) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (averageDuration_2 <= -0.36643627285957336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.37846361100673676) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08858950808644295) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6898222863674164) { + if (averageDuration_2 <= -0.45684851706027985) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485513687133789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (maxDuration_2 <= -0.3479366600513458) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (maxDuration_2 <= -0.3493625819683075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7594334483146667) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6288082599639893) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3393559604883194) { + if (maxDuration_2 <= -0.26309654116630554) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.956356555223465) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.24452946335077286) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5987571775913239) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.36372239887714386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3910958617925644) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.035508258268237114) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (averageDuration_2 <= -0.4474133104085922) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.34249405562877655) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (maxDuration_2 <= -0.23154182732105255) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.750958263874054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.613947868347168) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.41320350766181946) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4268268644809723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4434513449668884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3813876509666443) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.48559823632240295) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2206752896308899) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7655411958694458) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7890982329845428) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.4064783304929733) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5707090497016907) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.38829703629016876) { + if (maxDuration_2 <= -0.0679171122610569) { + if (averageDuration_2 <= -0.38002586364746094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4085203856229782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.410805806517601) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5805707275867462) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (maxDuration_2 <= -0.31491290032863617) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16563347727060318) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05890175327658653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.141227625310421) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6094601452350616) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8534824848175049) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.2893225997686386) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7363114953041077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8651732802391052) { + if (averageDuration_2 <= -0.31018516421318054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (averageDuration_2 <= -0.3054914027452469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.30377237498760223) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.29039858281612396) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5932562053203583) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.363677442073822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.040665093809366226) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5607988238334656) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486057877540588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7378681898117065) { + if (numDurations_2 <= 1.5776892304420471) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.047890182584524155) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5675286054611206) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818998217583) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4027012437582016) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.598081111907959) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.20690107345581055) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (maxDuration_2 <= -0.3708348423242569) { + if (maxDuration_2 <= -0.4281648248434067) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.2852247506380081) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20141274482011795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07486025243997574) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (averageDuration_2 <= -0.29829278588294983) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0767739973962307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (maxDuration_2 <= -0.3830752968788147) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (maxDuration_2 <= -0.3557474911212921) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2007257044315338) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01605401560664177) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7981161177158356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6879471838474274) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11507272720336914) { + if (averageDuration_2 <= -0.30687759816646576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.30310551822185516) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.18022698909044266) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.685827910900116) { + if (numDurations_2 <= 1.008537232875824) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4201842397451401) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39995812624692917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6126697659492493) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0534384846687317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.45547060668468475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731648460030556) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3718687891960144) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.747517317533493) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8987214267253876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.49880214035511017) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8261427581310272) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.744253933429718) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { + if (averageDuration_2 <= -0.4495915174484253) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.2664978951215744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7474215030670166) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9171100854873657) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.07610019110143185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5816256105899811) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748624712228775) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.074907898902893) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5887058973312378) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485283613204956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29847927391529083) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7459770739078522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7099223434925079) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5089184045791626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (averageDuration_2 <= -0.5104620456695557) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7104181349277496) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.47217778861522675) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4708722084760666) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.33538465201854706) { + if (averageDuration_2 <= -0.3478458821773529) { + if (averageDuration_2 <= -0.35028646886348724) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337136715650558) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454372882843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21545716375112534) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2976195961236954) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.05420057661831379) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.11005362495779991) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.668930321931839) { + if (maxDuration_2 <= -0.4943845868110657) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6457469165325165) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4950197637081146) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (averageDuration_2 <= -0.47629252076148987) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (averageDuration_2 <= -0.4891490191221237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5077300071716309) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7458292543888092) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486039102077484) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5286239683628082) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4606615751981735) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17025545984506607) { + if (maxDuration_2 <= -0.42046791315078735) { + if (averageDuration_2 <= -0.46668004989624023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7401580214500427) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (averageDuration_2 <= -0.3470374047756195) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1862863078713417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19960515201091766) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6749989092350006) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485586702823639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (averageDuration_2 <= -0.43673139810562134) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4366367906332016) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44459065794944763) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.43314145505428314) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.39739227294921875) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46866774559020996) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8093487322330475) { + if (averageDuration_2 <= -0.36962103843688965) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9917370676994324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (averageDuration_2 <= -0.4076513946056366) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.025448912754654884) { + if (maxDuration_2 <= -0.17032655328512192) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6561910510063171) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40391460061073303) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4478093683719635) { + if (maxDuration_2 <= -0.41773512959480286) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.983519434928894) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2751520872116089) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.700155109167099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (maxDuration_2 <= -0.5333474576473236) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.9961256682872772) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7020585536956787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5797589719295502) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5932983756065369) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.47584012150764465) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.532177746295929) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.014044463634491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4362926781177521) { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0844725370407104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5361006259918213) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6903150081634521) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.71750608086586) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (maxDuration_2 <= -0.49790501594543457) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8366779685020447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5719051659107208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7205657064914703) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5107482671737671) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.017642080783844) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5906648337841034) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.307508111000061) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5261394381523132) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485391795635223) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7677943408489227) { + if (maxDuration_2 <= -0.6094803214073181) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6071829497814178) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5546368062496185) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7482790648937225) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7963813841342926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.55804842710495) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6158093214035034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5280240774154663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6501077115535736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5339852571487427) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.725471168756485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484636604785919) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7447826862335205) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (maxDuration_2 <= -0.42687322199344635) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.46997955441474915) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486179769039154) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4796290397644043) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.720297634601593) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9318718314170837) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (maxDuration_2 <= -0.4857430160045624) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0699530839920044) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5945347547531128) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0515487790107727) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.268506944179535) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4681534916162491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (maxDuration_2 <= -0.5439392328262329) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484530508518219) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (maxDuration_2 <= -0.553269624710083) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8808378577232361) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8416959345340729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6176401376724243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6269329786300659) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6778150796890259) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0811641216278076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6637381911277771) { + if (maxDuration_2 <= -0.22174032777547836) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7340626120567322) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2355353236198425) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1447301506996155) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.17676475644111633) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7272540330886841) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9903765916824341) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.376254677772522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.550200343132019) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0005265474319458) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (maxDuration_2 <= -0.3297569453716278) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (averageDuration_2 <= -0.35993652045726776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.517245888710022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.054501403123140335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4440595507621765) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6324072480201721) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7400908172130585) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (maxDuration_2 <= -0.5807366669178009) { + if (averageDuration_2 <= -0.45982521772384644) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10027653723955154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28394149243831635) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9010830223560333) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20529384911060333) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (maxDuration_2 <= -0.4650661200284958) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9882445931434631) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6036377549171448) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9968165457248688) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.41473640501499176) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9626342952251434) { + if (maxDuration_2 <= -0.5730423629283905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.457562193274498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4953170716762543) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.37824735045433044) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0022378471912816167) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2039308324456215) { + if (maxDuration_2 <= -0.6604886054992676) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.26050466299057) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.1083666682243347) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6911803781986237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.4094298779964447) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6810666024684906) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8175210058689117) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (maxDuration_2 <= -0.521448940038681) { + if (averageDuration_2 <= -0.47019432485103607) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9232408702373505) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485074996948242) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5132758915424347) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (maxDuration_2 <= -0.5472696721553802) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (maxDuration_2 <= -0.49114011228084564) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.768743097782135) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.4933537095785141) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748610109090805) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.470766082406044) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460453018546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44873304665088654) { + if (maxDuration_2 <= -0.5478827357292175) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5930216312408447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485454380512238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5447825193405151) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5110073238611221) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2343200072646141) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5400852262973785) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5915840268135071) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4328085631132126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.18011285364627838) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5556620061397552) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7279088795185089) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344535857439041) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4827240854501724) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486019730567932) { + if (averageDuration_2 <= -0.4649517387151718) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835330963135) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (averageDuration_2 <= -0.4306986629962921) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7691725492477417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.393446609377861) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6825165748596191) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4511617422103882) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838244438171) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.46083788573741913) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.41775383055210114) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6355882883071899) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.738009512424469) { + if (maxDuration_2 <= -0.12319058552384377) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485676109790802) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5050598084926605) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7471512258052826) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7686004638671875) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5487850606441498) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482526898384094) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291473031044006) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7581554055213928) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.548366367816925) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479399204254) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (maxDuration_2 <= -0.23811417073011398) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6978890001773834) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8877497613430023) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9713059067726135) { + if (maxDuration_2 <= -0.2406822219491005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7620782852172852) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27359987050294876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6413657963275909) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (maxDuration_2 <= -0.5795513987541199) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2364568710327148) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5925949513912201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4855809062719345) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.046594943618401885) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4768766462802887) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484920620918274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.545476496219635) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.283537894487381) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (averageDuration_2 <= -0.49570733308792114) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485251128673553) { + if (averageDuration_2 <= -0.5029206275939941) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.27935898303985596) { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.42652927339076996) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4236503690481186) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4624898433685303) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (maxDuration_2 <= -0.41106657683849335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3213493227958679) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4475400298833847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10933853313326836) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5977640151977539) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6563952267169952) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5361257493495941) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (averageDuration_2 <= -0.4961100220680237) { + if (maxDuration_2 <= -0.5019244104623795) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8432371318340302) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8474216461181641) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483058273792267) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6139182448387146) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (numDurations_2 <= 1.008537232875824) { + if (maxDuration_2 <= -0.3855877071619034) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6897099614143372) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (averageDuration_2 <= -0.45100052654743195) { + if (maxDuration_2 <= -0.4476033002138138) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.591844379901886) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0386288166046143) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6631421148777008) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33925747871398926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.743899405002594) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.47409768402576447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42708034813404083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4764971286058426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7292035222053528) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.49841733276844025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39925357699394226) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1063312888145447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34024015069007874) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.530580997467041) { + if (averageDuration_2 <= -0.2467171847820282) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48052878677845) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7253695428371429) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.791291207075119) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144360721111298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.098836600780487) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6207029223442078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (maxDuration_2 <= -0.3710094690322876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7617442607879639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0712340474128723) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.26744791865348816) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.722954273223877) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (averageDuration_2 <= -0.2634769082069397) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5335469245910645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6790743172168732) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.351614311337471) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748550534248352) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7445378601551056) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2609957754611969) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7529622316360474) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.40303030610084534) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0384001731872559) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3895476758480072) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8314102292060852) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8928012549877167) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9385550916194916) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.453456997871399) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3598385751247406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (averageDuration_2 <= -0.2657439857721329) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4148102104663849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (averageDuration_2 <= -0.25159791111946106) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9757379591464996) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.1912466585636139) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2597963809967041) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7464922070503235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4374699890613556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8029898405075073) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4424275755882263) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6259874701499939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5219020843505859) { + if (numDurations_2 <= 2.4314171075820923) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.109816074371338) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935025334358215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.115248680114746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.16213075816631317) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (averageDuration_2 <= -0.2707052528858185) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.05452299118042) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5477696657180786) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485018074512482) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4159293621778488) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40187491476535797) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9961101114749908) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.13310105353593826) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (averageDuration_2 <= -0.2716637849807739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2826836556196213) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.2597251534461975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (maxDuration_2 <= -0.35999220609664917) { + if (averageDuration_2 <= -0.28293679654598236) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.749390035867691) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7209117412567139) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486073970794678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2609967738389969) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3711787015199661) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (maxDuration_2 <= -0.3931199461221695) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7799805104732513) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8237166702747345) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5833738744258881) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4031534194946289) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.39633896946907043) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.43883752822875977) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9569809138774872) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080834388733) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6675347983837128) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (averageDuration_2 <= -0.27070485055446625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0290856957435608) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.010598020628094673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7026547789573669) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4042154997587204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.038097321987152) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (averageDuration_2 <= -0.25044088810682297) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6364509463310242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5418795943260193) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.783620148897171) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670703738928) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (maxDuration_2 <= -0.2421409860253334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.10004199296236038) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36047783493995667) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (maxDuration_2 <= -0.2743011564016342) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4275834560394287) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (maxDuration_2 <= -0.28578707575798035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.004179835319519) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4926910102367401) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.52086141705513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.36311502754688263) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5401000678539276) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7429961562156677) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2894272208213806) { + if (maxDuration_2 <= -0.12396308034658432) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3363359570503235) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3206831216812134) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.1578606739640236) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.19574294239282608) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821968436241) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.09474093466997147) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.1773199513554573) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7048766911029816) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (averageDuration_2 <= 0.2523887902498245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3437920808792114) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.05343278683722019) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.044003456830978394) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7935460805892944) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.11785173416137695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485982179641724) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.3530064821243286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.24603942781686783) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.00288325548172) { + if (numDurations_2 <= -1.837222695350647) { + if (maxDuration_2 <= -0.2317165806889534) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1007722616195679) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.581272691488266) { + if (maxDuration_2 <= -0.40268075466156006) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7466290593147278) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5992238819599152) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1738765835762024) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2296112775802612) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (averageDuration_2 <= 0.2111334353685379) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.0423296093940735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5832706987857819) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 0.23321307450532913) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.1896548569202423) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.123512864112854) { + if (averageDuration_2 <= -0.2448047697544098) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0744428038597107) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.23738114535808563) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5934512615203857) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0618970394134521) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.1681392565369606) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.277814045548439) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5902966260910034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6079044044017792) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + if (numDurations_2 <= -1.2680706679821014) { + if (averageDuration_2 <= -0.016837602481245995) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7554211020469666) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7052259147167206) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (averageDuration_2 <= -0.1689627692103386) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397924542427) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795464992523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7073500752449036) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.170151710510254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.1416710466146469) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5897138118743896) { + if (averageDuration_2 <= -0.22400811314582825) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333690106868744) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3722195252776146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.3244738429784775) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7122727334499359) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (averageDuration_2 <= -0.23641596734523773) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.24511196464300156) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6946292519569397) { + if (averageDuration_2 <= -0.10026612132787704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (maxDuration_2 <= -0.045685144141316414) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (averageDuration_2 <= 0.042987169697880745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.04388689622282982) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748530238866806) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.0830427035689354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.20511864125728607) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (averageDuration_2 <= -0.2357349395751953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486163675785065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.637305736541748) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5884650349617004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.24472576379776) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (averageDuration_2 <= 0.28353404998779297) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484538853168488) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.31062352657318115) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.3351248651742935) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.3080146461725235) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1710380911827087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (maxDuration_2 <= -0.3823610842227936) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2602965235710144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7725189626216888) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { + if (averageDuration_2 <= -0.24076326191425323) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.23569945245981216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6509048640727997) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.115165650844574) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6834496855735779) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6501388847827911) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6652964651584625) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (maxDuration_2 <= -0.07779719308018684) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.64189013838768) { + if (averageDuration_2 <= -0.24108047783374786) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.1797604337334633) { + if (maxDuration_2 <= -0.367205411195755) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0694704055786133) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.14383991807699203) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2145853489637375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.18983230739831924) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9326036870479584) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6219784617424011) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.18786301463842392) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0356164574623108) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6830730140209198) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5880368947982788) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.109580636024475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.1805582195520401) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (averageDuration_2 <= -0.24189448356628418) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6661689579486847) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5931340754032135) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (averageDuration_2 <= -0.18173972517251968) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.613742470741272) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2531558722257614) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334689199924469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7094421684741974) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.11199888586997986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.007401691924314946) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0545474290847778) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3639002740383148) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6792885661125183) { + if (averageDuration_2 <= -0.09441689029335976) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6783876717090607) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.2569674402475357) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6838200092315674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6971320509910583) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.16740044206380844) { + if (maxDuration_2 <= -0.2488374337553978) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7991330921649933) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9228914678096771) { + if (maxDuration_2 <= -0.08214079961180687) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1358182430267334) { + if (maxDuration_2 <= -0.24255893379449844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2677497267723083) { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= -0.11115770787000656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3345186114311218) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2490962147712708) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6850359439849854) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6515218913555145) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1457267999649048) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.045991696417331696) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.1513097882270813) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9731535613536835) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (maxDuration_2 <= -0.15360576659440994) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4502701163291931) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6837252676486969) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.281745433807373) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7160948514938354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1793452501296997) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7346994578838348) { + if (averageDuration_2 <= 0.24847883731126785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2100608348846436) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6315911114215851) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.0005691051483154) { + if (maxDuration_2 <= -0.3665924519300461) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6648445129394531) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6322458684444427) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6054599583148956) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4165748506784439) { + if (averageDuration_2 <= -0.21011117845773697) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0478700399398804) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.11995896697044373) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0920674204826355) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7166780829429626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4848266690969467) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485277950763702) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (maxDuration_2 <= -0.3053671419620514) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6464059054851532) { + if (averageDuration_2 <= -0.24128907918930054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2154373973608017) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5004319697618484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.0508946068584919) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.23024196922779083) { + if (averageDuration_2 <= -0.23238848894834518) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (averageDuration_2 <= -0.22913186252117157) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4461263567209244) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.3610256314277649) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485158741474152) { + if (maxDuration_2 <= -0.29454754292964935) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.42696937918663025) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5130490958690643) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (averageDuration_2 <= -0.21454039961099625) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8786736130714417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42148226499557495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (averageDuration_2 <= -0.21205616742372513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.03393502160906792) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (maxDuration_2 <= -0.17711921781301498) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7401401400566101) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2260653972625732) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.2424069568514824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (maxDuration_2 <= -0.31782539188861847) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2475817799568176) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.259020447731018) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5305721759796143) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6787751913070679) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748605489730835) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.240234136581421) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748614490032196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.20604375004768372) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2261719107627869) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8935829401016235) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5651461780071259) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.17223966866731644) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.08208004757761955) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7552095353603363) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47838354110717773) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7334306538105011) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.846452385187149) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7178981602191925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0147919654846191) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.532191127538681) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (averageDuration_2 <= -0.19586879760026932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (averageDuration_2 <= -0.18694283068180084) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.0856764130294323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (averageDuration_2 <= -0.15411896258592606) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.95707568526268) { + if (averageDuration_2 <= -0.20437650382518768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.06648130714893341) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7999384105205536) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0914928913116455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3959844261407852) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6892985105514526) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0374455451965332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.2972804009914398) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39799924194812775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9603586792945862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.23355037719011307) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (averageDuration_2 <= -0.20765072852373123) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35780930519104004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.19434059411287308) { + if (maxDuration_2 <= -0.29422593116760254) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.10905060917139053) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7849734127521515) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9803360998630524) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.1951431855559349) { + if (maxDuration_2 <= -0.2538851946592331) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36205220222473145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.05066198669373989) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9110424220561981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.3149256706237793) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3955477625131607) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (maxDuration_2 <= -0.3805374950170517) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5595024228096008) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (averageDuration_2 <= -0.2384049966931343) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (maxDuration_2 <= -0.2808178663253784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9346790015697479) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.16313345730304718) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (averageDuration_2 <= -0.20082448422908783) { + if (maxDuration_2 <= -0.23878026008605957) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.852187842130661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (maxDuration_2 <= -0.38226477801799774) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7124348282814026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.344644159078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6733290553092957) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36745911836624146) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484953105449677) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { + if (maxDuration_2 <= -0.09280852600932121) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748590350151062) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.25467295944690704) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3441336750984192) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485979199409485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2242875173687935) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (averageDuration_2 <= -0.15035947412252426) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1258509755134583) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4633892774581909) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (averageDuration_2 <= -0.17466029524803162) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.24042631685733795) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (maxDuration_2 <= -0.388084813952446) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748583048582077) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (maxDuration_2 <= -0.30533936619758606) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43761681020259857) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.20778769254684448) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 0.004477373324334621) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.2327411249279976) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3190268576145172) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5364265739917755) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7016863524913788) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.0642496682703495) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6888016164302826) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0586062669754028) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8405185639858246) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (maxDuration_2 <= -0.22685886174440384) { + if (averageDuration_2 <= -0.2565150111913681) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8636920154094696) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4177165925502777) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5903356969356537) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43803970515727997) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7497720420360565) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.3441503643989563) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9727285504341125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7965058982372284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3638896942138672) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5230170786380768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3396598547697067) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2841406613588333) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44349202513694763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5143890678882599) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3521897941827774) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8379283249378204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8573937714099884) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (averageDuration_2 <= -0.25020357221364975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7402394711971283) { + if (maxDuration_2 <= -0.07524671778082848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5153296291828156) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7294360399246216) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3208869844675064) { + if (maxDuration_2 <= -0.07633834704756737) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.13060642033815384) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8584021031856537) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29660533368587494) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0021444342855829746) { + if (maxDuration_2 <= -0.08181406930088997) { + if (averageDuration_2 <= -0.28037771582603455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27776841819286346) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3900254964828491) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4734959751367569) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2499322071671486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5223480463027954) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0514491200447083) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7732266187667847) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.35476985573768616) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3482970595359802) { + if (averageDuration_2 <= -0.17909052968025208) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5458474159240723) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (maxDuration_2 <= -0.16531187295913696) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.20608334243297577) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.00955027062445879) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940978050232) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.21905796229839325) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7418599128723145) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3977990746498108) { + if (averageDuration_2 <= -0.09912717342376709) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5210371166467667) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (maxDuration_2 <= -0.3924412131309509) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2610907703638077) { + if (maxDuration_2 <= -0.3326544165611267) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.0794384814798832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.17543501406908035) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.473084956407547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.07511918991804123) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4585839807987213) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16147752851247787) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7907251119613647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (maxDuration_2 <= -0.17823107540607452) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (averageDuration_2 <= -0.2055349498987198) { + if (maxDuration_2 <= -0.42188870906829834) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (maxDuration_2 <= -0.13281997293233871) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36053191125392914) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.1616956666111946) { + if (maxDuration_2 <= -0.3366231620311737) { + if (maxDuration_2 <= -0.3409692794084549) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5080351829528809) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.07112113386392593) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7790552079677582) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44822995364665985) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27307097613811493) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (maxDuration_2 <= -0.2883070856332779) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42694225907325745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6117027699947357) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5946778655052185) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17447641491889954) { + if (averageDuration_2 <= -0.2530211955308914) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.265903502702713) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3353832811117172) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3418937623500824) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4365191012620926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7388883531093597) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0021231174468994) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.278314009308815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539397239685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6736651360988617) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7322461307048798) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (maxDuration_2 <= -0.29658880829811096) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485822141170502) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7337377071380615) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9118562936782837) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2777053862810135) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.31528282165527344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (maxDuration_2 <= -0.272173747420311) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (averageDuration_2 <= -0.2698711007833481) { + if (maxDuration_2 <= -0.4187912940979004) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8524399399757385) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21397068351507187) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.010948121547699) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25677254796028137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9515121877193451) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8703606426715851) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3654603660106659) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5659129619598389) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.26694755256175995) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2661726027727127) { + if (averageDuration_2 <= -0.27756930887699127) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6623232364654541) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26207540184259415) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3952498137950897) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485660016536713) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7838986217975616) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.20078985393047333) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4544541537761688) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.2885500639677048) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.736938089132309) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2398325353860855) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (averageDuration_2 <= -0.25714699923992157) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6590187251567841) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225075244904) { + if (maxDuration_2 <= -0.39672403037548065) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (maxDuration_2 <= -0.3810085505247116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.23948934674263) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (averageDuration_2 <= -0.279513880610466) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8412894904613495) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28334183990955353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5401448309421539) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.281432643532753) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9125480949878693) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.591004490852356) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485692501068115) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2824273854494095) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5997771620750427) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.2685035169124603) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14703184366226196) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7771967947483063) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9353727400302887) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5170929729938507) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485326826572418) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2021339312195778) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (averageDuration_2 <= -0.2610175311565399) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (averageDuration_2 <= -0.2662581354379654) { + if (maxDuration_2 <= -0.43308326601982117) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6385996639728546) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (averageDuration_2 <= -0.2782544940710068) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8268061876296997) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5740959346294403) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.657424122095108) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8571807742118835) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.202456533908844) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (maxDuration_2 <= -0.40260232985019684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7548597455024719) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.28280772268772125) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (averageDuration_2 <= -0.26394499838352203) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8008675873279572) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7609889507293701) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2905624657869339) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42697474360466003) { + if (averageDuration_2 <= -0.26357387006282806) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2138858437538147) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899798870087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.32735608518123627) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7936733365058899) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550786972046) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4129611998796463) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (averageDuration_2 <= -0.22882618010044098) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485603094100952) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4969044327735901) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (maxDuration_2 <= -0.26188093423843384) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.4652613401412964) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2781311571598053) { + if (maxDuration_2 <= -0.18095634877681732) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6264518201351166) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (maxDuration_2 <= -0.36662550270557404) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (maxDuration_2 <= -0.419176310300827) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3224613815546036) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.22998777776956558) { + if (maxDuration_2 <= -0.1473424807190895) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25681714713573456) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484798729419708) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1578196287155151) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27534817159175873) { + if (averageDuration_2 <= -0.22778252512216568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1896490901708603) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.639798104763031) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6787176728248596) { + if (maxDuration_2 <= -0.19379205256700516) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26610569655895233) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3285878300666809) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.03564050234854221) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26646843552589417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6900342404842377) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (maxDuration_2 <= -0.14748673141002655) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038346767426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (maxDuration_2 <= -0.30952081084251404) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3353877514600754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (maxDuration_2 <= -0.0537569560110569) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485448718070984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2514399588108063) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28584088385105133) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.3631049543619156) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (averageDuration_2 <= -0.18558041751384735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5758938193321228) { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= -0.3412022739648819) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7458773255348206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.913247674703598) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (averageDuration_2 <= -0.18869300186634064) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23939962685108185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.967848002910614) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9231318235397339) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991199404001) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9291076958179474) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485543489456177) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3198850303888321) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665165930986404) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2728373259305954) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014949262142181) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (maxDuration_2 <= -0.19027145206928253) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7140167355537415) { + if (averageDuration_2 <= -0.234145388007164) { + if (maxDuration_2 <= -0.35643628239631653) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3192680776119232) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486122846603394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.24831096082925797) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22427897155284882) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7833621799945831) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.42821288108825684) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20315079391002655) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.3387858867645264) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.1988108903169632) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.20016694068908691) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6616968810558319) { + if (maxDuration_2 <= -0.08582834154367447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.39954543113708496) { + if (maxDuration_2 <= -0.40026476979255676) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.209187850356102) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.45689286291599274) { + if (averageDuration_2 <= -0.22807643562555313) { + if (maxDuration_2 <= -0.21375722438097) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.23909815400838852) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5295973122119904) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.82614666223526) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (averageDuration_2 <= -0.23049189150333405) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41212454438209534) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27913711965084076) { + if (maxDuration_2 <= -0.11588393896818161) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0322797298431396) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.19132478535175323) { + if (averageDuration_2 <= -0.19212351739406586) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (maxDuration_2 <= -0.1207871362566948) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733549296855927) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + if (averageDuration_2 <= 0.23367444425821304) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1931182742118835) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (averageDuration_2 <= 0.10792051628232002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74852454662323) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7218490242958069) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (averageDuration_2 <= -0.17093124240636826) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6449516415596008) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7420169711112976) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.739361971616745) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8147646188735962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748597651720047) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7922976016998291) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.28193628787994385) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.418925404548645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.2659737467765808) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9349691867828369) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6781851649284363) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16347970813512802) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48216956853866577) { + if (maxDuration_2 <= -0.11287758499383926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.04728280380368233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2814740240573883) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162634164094925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7098142802715302) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (maxDuration_2 <= -0.28511838614940643) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + if (maxDuration_2 <= -0.07321551814675331) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331952571869) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (averageDuration_2 <= -0.2074688822031021) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2822565287351608) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (maxDuration_2 <= -0.44082584977149963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7424038648605347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6498822271823883) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.26150213181972504) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6316382884979248) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (maxDuration_2 <= -0.34794169664382935) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.26624464988708496) { + if (maxDuration_2 <= -0.2999219745397568) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.045973898842930794) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.2592342346906662) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.030857334844768047) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3813024312257767) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0369514599442482) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8100941777229309) { + if (averageDuration_2 <= -0.2761097103357315) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8097307085990906) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14618854969739914) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8048931956291199) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.426584854722023) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5871250033378601) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.2402190864086151) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748504251241684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.923337996006012) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2869911938905716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05177626945078373) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8075879812240601) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.09588830173015594) { + if (averageDuration_2 <= -0.2508274167776108) { + if (maxDuration_2 <= -0.3264417052268982) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5148786902427673) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.27885277569293976) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2445913553237915) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= -0.27563507854938507) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.24052101373672485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.20517390221357346) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14677874743938446) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (maxDuration_2 <= -0.21784735471010208) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.032900355756282806) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (maxDuration_2 <= -0.3064814358949661) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.509726345539093) { + if (averageDuration_2 <= -0.2846863716840744) { + if (averageDuration_2 <= -0.2861618399620056) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.638380229473114) { + if (maxDuration_2 <= -0.40449170768260956) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8382810354232788) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7233429849147797) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322683811188) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12909957766532898) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13346882164478302) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6535920202732086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7258325517177582) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.2228839173913002) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5292870253324509) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2791253328323364) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987979784607887) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7233713269233704) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4482111483812332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39988990128040314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.2833700329065323) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (maxDuration_2 <= -0.2741820365190506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6481418311595917) { + if (averageDuration_2 <= -0.2582439035177231) { + if (maxDuration_2 <= -0.264588326215744) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22319337725639343) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485465109348297) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.2633528411388397) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7454572916030884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13470125198364258) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.920521080493927) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 1.2931131720542908) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.83772411942482) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (maxDuration_2 <= -0.31173184514045715) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= -0.25389277935028076) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1721750795841217) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2145916372537613) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14986799657344818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (maxDuration_2 <= -0.14705628901720047) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2288569137454033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20536451786756516) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377739667892456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21907832473516464) { + if (averageDuration_2 <= -0.2604185491800308) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0836245734244585) { + if (averageDuration_2 <= -0.23343855887651443) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2561086267232895) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11848346143960953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6477150321006775) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473682403564) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (averageDuration_2 <= -0.2801646441221237) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.27239806950092316) { + if (maxDuration_2 <= -0.1380498968064785) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07036935165524483) { + if (maxDuration_2 <= -0.13587180525064468) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379605531692505) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2596648782491684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.11747943982481956) { + if (averageDuration_2 <= -0.24797318875789642) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6675136685371399) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (maxDuration_2 <= -0.18224287033081055) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2610100358724594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15766098350286484) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3420938104391098) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6679880619049072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.042957497760653496) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.28055185079574585) { + if (averageDuration_2 <= -0.2677660137414932) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.543742448091507) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2785010188817978) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2683720737695694) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.24810295552015305) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (averageDuration_2 <= -0.2773953080177307) { + if (maxDuration_2 <= -0.26856476068496704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0318717658519745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25394001603126526) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2679593414068222) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.24917978048324585) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.00814439170062542) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -0.4143427312374115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.958763062953949) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.22441639751195908) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6893966495990753) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4439823776483536) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.691208690404892) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8230580985546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.06381170824170113) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.19548644125461578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.24826394021511078) { + if (maxDuration_2 <= -0.33553922176361084) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (averageDuration_2 <= -0.2661000192165375) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.578790932893753) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6279758214950562) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5692433714866638) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7084825038909912) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015798807144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6006219387054443) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.2842845022678375) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6929503977298737) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8199627101421356) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044531345367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9033576548099518) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8406788408756256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.2612479478120804) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11514891684055328) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45369894802570343) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.2751935124397278) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9287764430046082) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.25626711547374725) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2872167229652405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.410798043012619) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12764527648687363) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (averageDuration_2 <= -0.27349600195884705) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10608633980154991) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.27582331001758575) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (averageDuration_2 <= -0.2818043678998947) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.12759759277105331) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.061789870262146) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2299851030111313) { + if (maxDuration_2 <= -0.2237512245774269) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080238342285) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5614892542362213) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.043881820514798164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.29040390253067017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (averageDuration_2 <= -0.18496745824813843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0013210688484832644) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368339061737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8100003600120544) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= -0.2715988755226135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.16359472274780273) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.21660760790109634) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.1966957077383995) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3292957693338394) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.039249714463949203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7054912745952606) { + if (averageDuration_2 <= 0.0009743962436914444) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.41863176226615906) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940378189087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4068650007247925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3182181417942047) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7807172238826752) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.2694232314825058) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48930469155311584) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1483902707695961) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5944550633430481) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5142034292221069) { + if (maxDuration_2 <= -0.03438427112996578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (maxDuration_2 <= -0.40340517461299896) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.24718830734491348) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.545611709356308) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2789292186498642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23131079226732254) { + if (averageDuration_2 <= -0.24193211644887924) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.590805172920227) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036517620087) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.294686421751976) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (averageDuration_2 <= -0.19888681173324585) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18907227367162704) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.27738210558891296) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.3579053580760956) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6313998401165009) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17327073961496353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.20408271253108978) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.15315686911344528) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (averageDuration_2 <= -0.18946343660354614) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6417744755744934) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485648691654205) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.357895165681839) { + if (averageDuration_2 <= 0.06967776082456112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4892125725746155) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4436546862125397) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.33277857303619385) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.23737216740846634) { + if (maxDuration_2 <= -0.2776317298412323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1390169858932495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.236459419131279) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7210432887077332) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5234153568744659) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08700080588459969) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.22233781218528748) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600832462311) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6631695926189423) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.42108336091041565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.15575862675905228) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.596440315246582) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (averageDuration_2 <= -0.23228462785482407) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07731792330741882) { + if (maxDuration_2 <= -0.4351624995470047) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.22395853698253632) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06479034572839737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.36404065787792206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.23173528164625168) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (maxDuration_2 <= -0.38920433819293976) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11565437540411949) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31106923520565033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.23786932229995728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080834388733) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.608068972826004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5461540222167969) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5092349648475647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (maxDuration_2 <= -0.4012725502252579) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2365148812532425) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4689917266368866) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (averageDuration_2 <= -0.13831698149442673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.516241043806076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (averageDuration_2 <= -0.2143319770693779) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18428974598646164) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08554983884096146) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.30045635998249054) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5669287443161011) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1942695826292038) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.22393422573804855) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (averageDuration_2 <= -0.2688061594963074) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33296892046928406) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606725335121) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.5612579137086868) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.37244056165218353) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.29339762032032013) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.152395099401474) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43922701478004456) { + if (averageDuration_2 <= -0.22077295184135437) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11248533055186272) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333691596984863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5578545331954956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.36362679302692413) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.38087184727191925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5248203873634338) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26057150959968567) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (averageDuration_2 <= -0.2571285516023636) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4283716380596161) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.01868955628015101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.22864992171525955) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05839197151362896) { + if (averageDuration_2 <= -0.23892468959093094) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.268309473991394) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5118407309055328) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.10460836440324783) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2528271824121475) { + if (averageDuration_2 <= -0.3269695043563843) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08821799606084824) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (averageDuration_2 <= -0.4989064633846283) { + if (numDurations_2 <= -0.12976673245429993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4125606417655945) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6339189410209656) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.027930138632655144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5211040675640106) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5165899395942688) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019880056381226) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.39154790341854095) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485997080802917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6027671992778778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (maxDuration_2 <= -0.2841053456068039) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4572376608848572) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15789134800434113) { + if (maxDuration_2 <= -0.5957201421260834) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7244468629360199) { + if (averageDuration_2 <= -0.6669583916664124) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5603378117084503) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (maxDuration_2 <= -0.3346400856971741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5805412530899048) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3296091705560684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948889613152) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5601940751075745) { + if (maxDuration_2 <= -0.5088740587234497) { + if (averageDuration_2 <= -0.5944306552410126) { + if (averageDuration_2 <= -0.7100886106491089) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31590230762958527) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5481206774711609) { + if (averageDuration_2 <= -0.5680032074451447) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7477593719959259) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (averageDuration_2 <= -0.5106007158756256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + if (maxDuration_2 <= -0.4827265590429306) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09361106529831886) { + if (averageDuration_2 <= -0.6067487597465515) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2860908806324005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8923229575157166) { + if (maxDuration_2 <= -0.4859583228826523) { + if (averageDuration_2 <= -0.5634881258010864) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3086474984884262) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6676608622074127) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6602632999420166) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748130202293396) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4057624936103821) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (averageDuration_2 <= -0.6048232018947601) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13716164976358414) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04838144592940807) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6917317807674408) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (maxDuration_2 <= -0.40035584568977356) { + if (averageDuration_2 <= -0.5483162999153137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.20353782922029495) { + if (averageDuration_2 <= -0.4006756395101547) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2909836173057556) { + if (maxDuration_2 <= -0.4715954065322876) { + if (averageDuration_2 <= -0.5518810451030731) { + if (maxDuration_2 <= -0.5560278296470642) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + if (maxDuration_2 <= -0.7255154252052307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5784659087657928) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07238395884633064) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002657651901245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7415772378444672) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1335732415318489) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (averageDuration_2 <= -0.5721547603607178) { + if (maxDuration_2 <= -0.5978019833564758) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (averageDuration_2 <= -0.6124387979507446) { + if (numDurations_2 <= -0.6989187151193619) { + if (maxDuration_2 <= -0.7166182100772858) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.6833442151546478) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6828599572181702) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6535961925983429) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2617175728082657) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6647436320781708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6605772078037262) { + if (averageDuration_2 <= -0.6295326054096222) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21005327999591827) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (averageDuration_2 <= -0.6623657941818237) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30005142092704773) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6493828296661377) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30107834935188293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3925536572933197) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6797971725463867) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5996951758861542) { + if (maxDuration_2 <= -0.6614028811454773) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 6.13090455532074) { + if (averageDuration_2 <= -0.7003266215324402) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23309477418661118) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6249447762966156) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6840326488018036) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34428687393665314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.697542279958725) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6278670728206635) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2851773053407669) { + if (averageDuration_2 <= -0.677367091178894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.553671658039093) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2714698165655136) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5735555291175842) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6179570853710175) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (averageDuration_2 <= -0.613285630941391) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.279721274971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5503088533878326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 6.13090455532074) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + if (averageDuration_2 <= -0.6831077635288239) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2689694166183472) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (averageDuration_2 <= -0.6909444630146027) { + if (averageDuration_2 <= -0.7082001864910126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22890909761190414) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45376919209957123) { + if (averageDuration_2 <= -0.6819539070129395) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6348273754119873) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5225249826908112) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6110276579856873) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19313225895166397) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5204704403877258) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (averageDuration_2 <= -0.7202321588993073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.7384777069091797) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (averageDuration_2 <= -0.5870723724365234) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27039894461631775) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.675494909286499) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2073439210653305) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6364002823829651) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (averageDuration_2 <= -0.5857506990432739) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4358774423599243) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36888784170150757) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486236691474915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485497295856476) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34155137836933136) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485657334327698) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22496283054351807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37853653728961945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (averageDuration_2 <= -0.5964904129505157) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3772291988134384) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485852241516113) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03190133138559759) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6542653739452362) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331878066063) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2523317188024521) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.654164582490921) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5827449262142181) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5934374332427979) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2944009602069855) { + if (averageDuration_2 <= -0.593600869178772) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (maxDuration_2 <= -0.6688591241836548) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6261325776576996) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.6348983645439148) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5342010855674744) { + if (averageDuration_2 <= -0.5942671597003937) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37196215987205505) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18949556350708008) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5878232419490814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27998705208301544) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6678718030452728) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (maxDuration_2 <= -0.8009085953235626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.671004444360733) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4962782859802246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36940766870975494) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6031054854393005) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3396105617284775) { + if (averageDuration_2 <= -0.6483062207698822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (maxDuration_2 <= -0.6150900423526764) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (averageDuration_2 <= -0.6408379077911377) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 6.415480613708496) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28192557394504547) { + if (maxDuration_2 <= -0.5394309759140015) { + if (averageDuration_2 <= -0.5908102691173553) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6502960324287415) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6983753442764282) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6154563724994659) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5918280184268951) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5966546833515167) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748603343963623) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32093851268291473) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (maxDuration_2 <= -0.5681339204311371) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4645354598760605) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486209571361542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2592367082834244) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34241510927677155) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (maxDuration_2 <= -0.5081599652767181) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6422117650508881) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5328779518604279) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.47682543098926544) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6048415005207062) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21266530454158783) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4923633635044098) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486149668693542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.6856320798397064) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5274665653705597) { + if (maxDuration_2 <= -0.13781708106398582) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4944934695959091) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5897004306316376) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486236691474915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5842593312263489) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3320669084787369) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.4000113755464554) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41197963058948517) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485391795635223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.47122809290885925) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25654685497283936) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38799265027046204) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748023122549057) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424444913864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (averageDuration_2 <= -0.4024594724178314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25328144431114197) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14234451204538345) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2625197470188141) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485034465789795) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5339661836624146) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3545491695404053) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5819776952266693) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6240127682685852) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5514624118804932) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46276040375232697) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5850118398666382) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20209894329309464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6265810132026672) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (maxDuration_2 <= -0.6034879088401794) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20224648714065552) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (maxDuration_2 <= -0.5570053458213806) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29953649640083313) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3239108622074127) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.5638058185577393) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7576421499252319) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486049830913544) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (maxDuration_2 <= -0.6348981857299805) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46621835231781006) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5700456202030182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (maxDuration_2 <= -0.575884073972702) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5352407395839691) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2621181756258011) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2664329558610916) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31939294934272766) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (maxDuration_2 <= -0.5826969146728516) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (maxDuration_2 <= -0.4901042878627777) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (averageDuration_2 <= -0.522789865732193) { + if (maxDuration_2 <= -0.6233289837837219) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2803456336259842) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5542067289352417) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2857186198234558) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2899581640958786) { + if (averageDuration_2 <= -0.5093207061290741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.5321793258190155) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35915620625019073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.301122322678566) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6077126562595367) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5589925646781921) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (averageDuration_2 <= -0.5597261488437653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486274838447571) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462590157985687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (averageDuration_2 <= -0.5663965940475464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31620649993419647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3435003161430359) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5924984514713287) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (maxDuration_2 <= -0.5942942202091217) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22941620647907257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5463476479053497) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (maxDuration_2 <= -0.48249855637550354) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32127560675144196) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6031866371631622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6094876825809479) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748561680316925) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3328823745250702) { + if (averageDuration_2 <= -0.45805636048316956) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484555244445801) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36929039657115936) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5346470773220062) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.38214685022830963) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3405192345380783) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5372048020362854) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (averageDuration_2 <= -0.531667560338974) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3342519551515579) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21165285259485245) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7459463477134705) { + if (maxDuration_2 <= -0.5889197587966919) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (averageDuration_2 <= -0.4584030658006668) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3487404137849808) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5675159692764282) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3800422102212906) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5062882900238037) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (maxDuration_2 <= -0.6159765422344208) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5691476166248322) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20891018211841583) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5460633635520935) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3088129311800003) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.619623601436615) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5251013040542603) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21084773540496826) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5504649579524994) { + if (averageDuration_2 <= -0.5697771608829498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37935376167297363) { + if (maxDuration_2 <= -0.6679753065109253) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2789972722530365) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3854460269212723) { + if (averageDuration_2 <= -0.5441325902938843) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.602842390537262) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (maxDuration_2 <= -0.48951922357082367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5225012302398682) { + if (maxDuration_2 <= -0.4053274393081665) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5596130192279816) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (maxDuration_2 <= -0.4567512422800064) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486073970794678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (averageDuration_2 <= -0.5409604907035828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44185522198677063) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5417773127555847) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2298821285367012) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05795922130346298) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.532802164554596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (maxDuration_2 <= -0.28282102942466736) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7476115524768829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= -0.3565696179866791) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4050462692975998) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.41245976090431213) { + if (maxDuration_2 <= -0.3913572132587433) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36205707490444183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.47941450774669647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (averageDuration_2 <= -0.3780890852212906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4443804621696472) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3648296147584915) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30098845064640045) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485493421554565) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8067096173763275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.47056202590465546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4476628750562668) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485440671443939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4398176968097687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7445995807647705) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5907306969165802) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6031337678432465) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2605813145637512) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.35472045838832855) { + if (averageDuration_2 <= -0.4002620726823807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4493653178215027) { + if (maxDuration_2 <= -0.39770668745040894) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4684649854898453) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42437972128391266) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34205032885074615) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.45398305356502533) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.47470422089099884) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4613882303237915) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.49327416718006134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.21275942027568817) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33707955479621887) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (maxDuration_2 <= -0.3635760247707367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.23939812928438187) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3574554771184921) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (averageDuration_2 <= -0.3500021994113922) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.33107639849185944) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (maxDuration_2 <= -0.18180231750011444) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30909237265586853) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4716014862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= -0.2960367202758789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.39227962493896484) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.256836473941803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23078802227973938) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5512620806694031) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5726881623268127) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3110172003507614) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2501889690756798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19596286863088608) { + if (maxDuration_2 <= -0.6544354259967804) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34702758491039276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5878972709178925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6396775543689728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5722808837890625) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (averageDuration_2 <= -0.6554039716720581) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8067096173763275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5686486065387726) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6054034233093262) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6294295191764832) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30324502289295197) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36107607185840607) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41816259920597076) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35040828585624695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485269904136658) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.63682821393013) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40183626115322113) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (averageDuration_2 <= -0.559341698884964) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (maxDuration_2 <= -0.6690009832382202) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5656287372112274) { + if (maxDuration_2 <= -0.3573988378047943) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5687164962291718) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3236040025949478) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5834030210971832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21639560908079147) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3730756640434265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5897201001644135) { + if (averageDuration_2 <= -0.5544480085372925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485714256763458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74849534034729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5902937650680542) { + if (maxDuration_2 <= -0.7323030829429626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { + if (maxDuration_2 <= -0.6254056394100189) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5314352512359619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3081260472536087) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460499584675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.5116576254367828) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (maxDuration_2 <= -0.5309035181999207) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3295358568429947) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35200248658657074) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6280775666236877) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5738554298877716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36422911286354065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (maxDuration_2 <= -0.457050159573555) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4883769005537033) { + if (maxDuration_2 <= -0.5169533491134644) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34977318346500397) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.47888369858264923) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (maxDuration_2 <= -0.4213823080062866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.27067437767982483) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.40454475581645966) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.49495241045951843) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28387095034122467) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2880137711763382) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6369091868400574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5352841317653656) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5226706564426422) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20181266218423843) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.509487122297287) { + if (averageDuration_2 <= -0.5486159026622772) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6134843826293945) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2942192256450653) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5799059271812439) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4418666213750839) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4680694490671158) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22761642187833786) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4513641744852066) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3061124086380005) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6020664870738983) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5520569384098053) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7944985032081604) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6395776867866516) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17619893699884415) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5170868337154388) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7624516487121582) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (maxDuration_2 <= -0.277872271835804) { + if (maxDuration_2 <= -0.6453761756420135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05396449379622936) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (maxDuration_2 <= -0.6199630796909332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05793486721813679) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5376519560813904) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.7561812698841095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46614550054073334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093146696686745) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2467629760503769) { + if (averageDuration_2 <= -0.5239435434341431) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3645829558372498) { + if (averageDuration_2 <= -0.5707944333553314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.43731024861335754) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6444163620471954) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5204966366291046) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7698073387145996) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (averageDuration_2 <= -0.46517519652843475) { + if (maxDuration_2 <= -0.520278811454773) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.630760133266449) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.28276537358760834) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283403396606) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11433595791459084) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (averageDuration_2 <= -0.6412354707717896) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 6.415480613708496) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20738837867975235) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07385984063148499) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12097278609871864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4630904495716095) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1081945039331913) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7278706133365631) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5485115051269531) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09539277479052544) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07248801738023758) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + if (averageDuration_2 <= -0.6985616981983185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.723607748746872) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5774365663528442) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (averageDuration_2 <= -0.727884829044342) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7102107107639313) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.723490446805954) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6875452995300293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.7127822041511536) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.7489252388477325) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.041255585849285126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.283527672290802) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.36245162785053253) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (maxDuration_2 <= -0.7658460438251495) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27466876804828644) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4613555371761322) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (averageDuration_2 <= -0.6644099652767181) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6853641867637634) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5215021222829819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.013588526286184788) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.45482900738716125) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13350923731923103) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3457206040620804) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07133554667234421) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6090952157974243) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485684156417847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07354965060949326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.453784704208374) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39596104621887207) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6337987780570984) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5333801209926605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703441977500916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (maxDuration_2 <= -0.6080213785171509) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3643207997083664) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74850994348526) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6328724920749664) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.7175930738449097) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04844321496784687) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0708580613136292) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4902585446834564) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.6429785192012787) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2228042185306549) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485164403915405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618085026741028) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4520620703697205) { + if (averageDuration_2 <= -0.5575141310691833) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4418955445289612) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25773440301418304) { + if (maxDuration_2 <= -0.6011247932910919) { + if (averageDuration_2 <= -0.5850869715213776) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913831710815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06258528865873814) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.513752281665802) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.298371821641922) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (maxDuration_2 <= -0.6554587483406067) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322981834412) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5735531747341156) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.0718897394835949) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485456764698029) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.2076711803674698) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5692130029201508) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5804140269756317) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483691573143005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5611658096313477) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4235472083091736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5183549225330353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.43246516585350037) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09786381945014) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25357477366924286) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344535857439041) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5576917231082916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12854060530662537) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5888699293136597) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6226044595241547) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5959138870239258) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4745524674654007) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2858542650938034) { + if (maxDuration_2 <= -0.5450409948825836) { + if (averageDuration_2 <= -0.5867359936237335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5827563405036926) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.168618083000183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550786972046) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.389140322804451) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.434324249625206) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.351614311337471) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07635049149394035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.47842347621917725) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.004393589682877064) { + if (averageDuration_2 <= -0.48636777698993683) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4185950756072998) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (maxDuration_2 <= -0.5382533371448517) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05510523542761803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11081308498978615) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6334449350833893) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485879063606262) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485797703266144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (averageDuration_2 <= -0.5299005508422852) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (averageDuration_2 <= -0.49599309265613556) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (maxDuration_2 <= -0.6620412170886993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5728169679641724) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17110247910022736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486147284507751) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5826235711574554) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9895495176315308) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12510943040251732) { + if (numDurations_2 <= 1.0085372477769852) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4932494163513184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5407021641731262) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685033559799) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { + if (averageDuration_2 <= -0.509421706199646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.46744465827941895) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35576219856739044) { + if (averageDuration_2 <= -0.5209194421768188) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6844632029533386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01140963239595294) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6665643751621246) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4243810325860977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.35142163932323456) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.2889275699853897) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (averageDuration_2 <= -0.45766882598400116) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7238774597644806) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167270183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.583746999502182) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.319937065243721) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (maxDuration_2 <= -0.563392847776413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6327060759067535) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (averageDuration_2 <= -0.49942104518413544) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615192413330078) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (numDurations_2 <= 3.2851450443267822) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.16891080141067505) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5402468740940094) { + if (maxDuration_2 <= -0.5712746381759644) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5074861943721771) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4345245957374573) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5376105308532715) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.649873822927475) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6931098997592926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619413614273071) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.07493534963577986) { + if (maxDuration_2 <= -0.5544473826885223) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.1318272426724434) { + if (maxDuration_2 <= -0.48495782911777496) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (averageDuration_2 <= -0.5551666021347046) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1967049166560173) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485508024692535) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484709322452545) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (averageDuration_2 <= -0.47925202548503876) { + if (maxDuration_2 <= -0.6836399137973785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5274514257907867) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5878421664237976) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23256254941225052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4967978149652481) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (averageDuration_2 <= -0.48712828755378723) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.218268733471632) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5137658715248108) { + if (averageDuration_2 <= -0.5585663020610809) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.4870954751968384) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5877294838428497) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6611500382423401) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (averageDuration_2 <= -0.5437621176242828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5578376948833466) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660716414452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.46949028968811035) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45505067706108093) { + if (averageDuration_2 <= -0.5653768181800842) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4901810586452484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4992946982383728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.5308720469474792) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4118057042360306) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.47901709377765656) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6025554835796356) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (averageDuration_2 <= -0.5317646265029907) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6040748059749603) { + if (averageDuration_2 <= -0.5247578322887421) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.17203358560800552) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44016341865062714) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5145729184150696) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291220307350159) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4436039924621582) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8526124060153961) { + if (averageDuration_2 <= -0.3838379234075546) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.390558585524559) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406549453735) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.3247819542884827) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251758337021) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485651671886444) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.14211505651474) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836058139801025) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5515397191047668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.40896493196487427) { + if (maxDuration_2 <= -0.3392142057418823) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5169866383075714) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09705497696995735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8557784855365753) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485814094543457) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05475788190960884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670051813126) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485676109790802) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14788035303354263) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.067494750022888) { + if (maxDuration_2 <= -0.2984352558851242) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 0.4393852949142456) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.124604046344757) { + if (maxDuration_2 <= -0.3766549229621887) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.581117033958435) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.37441979348659515) { + if (averageDuration_2 <= -0.37539370357990265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.004646758548915386) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.045587968081235886) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4421444535255432) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.688913106918335) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 0.15480923652648926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (maxDuration_2 <= -0.37563668191432953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12511024251580238) { + if (averageDuration_2 <= -0.3516463339328766) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167270183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2049425542354584) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0572613924741745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27345573902130127) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5702328383922577) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25724008679389954) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27581942081451416) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.041750965639948845) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.45641449093818665) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4201412945985794) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485862672328949) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20823511481285095) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.510930597782135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4138586223125458) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6318988502025604) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.702243834733963) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4546239972114563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.4283875823020935) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4602272510528564) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.140251100063324) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2961076498031616) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777604699135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018469229340553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.772491455078125) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617165923118591) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12374766916036606) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8768020272254944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5622496008872986) { + if (averageDuration_2 <= -0.43720293045043945) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485703229904175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960519313812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.12733162194490433) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42567162215709686) { + if (averageDuration_2 <= -0.43235644698143005) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (maxDuration_2 <= -0.23102258890867233) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.36689135432243347) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.43155695497989655) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (maxDuration_2 <= -0.34149082005023956) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5404568910598755) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3411053866147995) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (maxDuration_2 <= -0.29296964406967163) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9264280498027802) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48841245472431183) { + if (numDurations_2 <= 0.15480923652648926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.44576945900917053) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4056263566017151) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10390245914459229) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (averageDuration_2 <= -0.3480192869901657) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623116254806519) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.40550215542316437) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613160490989685) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42109276354312897) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (maxDuration_2 <= -0.45442621409893036) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4347403645515442) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1968777179718018) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.24359667301178) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9317687749862671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3862829953432083) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.766765683889389) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38537317514419556) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7591971755027771) { + if (averageDuration_2 <= -0.3923813998699188) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.15625761449337006) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3233163058757782) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9236379861831665) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7076879441738129) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.234639286994934) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6772132217884064) { + if (averageDuration_2 <= -0.3797043263912201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615964889526367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.299040973186493) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8721061646938324) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5199248492717743) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9208518266677856) { + if (maxDuration_2 <= -0.4699162393808365) { + if (averageDuration_2 <= -0.3668360561132431) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.38309143483638763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.36390842497348785) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.602776974439621) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (maxDuration_2 <= -0.24398231506347656) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618231654167175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48208679258823395) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49404236674308777) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2628833651542664) { + if (averageDuration_2 <= -0.4361456632614136) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6180945336818695) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2561350241303444) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5318169742822647) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.517959475517273) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5568408370018005) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.32207027077674866) { + if (averageDuration_2 <= -0.5349857211112976) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4249383509159088) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49135005474090576) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14120978116989136) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29927270114421844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.697102427482605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5664648115634918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5530392229557037) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09434778615832329) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26528115570545197) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39096294343471527) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32073213160037994) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7277062237262726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5795845687389374) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13825879245996475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5443798899650574) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.506406307220459) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.49287591874599457) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2133997157216072) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7414428889751434) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27738118171691895) { + if (averageDuration_2 <= -0.43330565094947815) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6573804020881653) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3103039562702179) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14733772724866867) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4291663020849228) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= -0.3711360991001129) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2479216530919075) { + if (maxDuration_2 <= -0.38824954628944397) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.640409916639328) { + if (maxDuration_2 <= -0.4615836590528488) { + if (averageDuration_2 <= -0.48789890110492706) { + if (averageDuration_2 <= -0.6482199728488922) { + if (maxDuration_2 <= -0.7167143225669861) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3774325102567673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.33030788600444794) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015798807144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (averageDuration_2 <= -0.6111305356025696) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.2931131720542908) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2606446295976639) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.5164949893951416) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04641691967844963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.43847134709358215) { + if (maxDuration_2 <= -0.363069549202919) { + if (averageDuration_2 <= -0.5644111037254333) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2830994576215744) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7383382618427277) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5557722747325897) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5412823259830475) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.656618744134903) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.214928150177002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612974524497986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2490918040275574) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7270320355892181) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32332007586956024) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4036276638507843) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7277178466320038) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4908767193555832) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1391805112361908) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22522208094596863) { + if (numDurations_2 <= 6.13090455532074) { + if (averageDuration_2 <= -0.5384972393512726) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12233728542923927) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4202587455511093) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6482833027839661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.7067766189575195) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0651512444019318) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18302758783102036) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27040667831897736) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1653968021273613) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3761455714702606) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22446826100349426) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (averageDuration_2 <= -0.345064714550972) { + if (averageDuration_2 <= -0.45101140439510345) { + if (maxDuration_2 <= -0.5347835123538971) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6334137320518494) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.698310136795044) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06506835110485554) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.472336307168007) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3348274379968643) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09947209432721138) { + if (maxDuration_2 <= -0.34507226943969727) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14106550067663193) { + if (maxDuration_2 <= -0.48420827090740204) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (averageDuration_2 <= -0.5775834321975708) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2461043894290924) { + if (averageDuration_2 <= -0.6984599828720093) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6498123407363892) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6417047679424286) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6013825535774231) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4234669357538223) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5181497633457184) { + if (averageDuration_2 <= -0.6755379736423492) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5975435376167297) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988297700882) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7321714758872986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2709021270275116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6275915205478668) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6345901191234589) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5085448622703552) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.292544662952423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48683492839336395) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10884817317128181) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2374681755900383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.36262382566928864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.45277877151966095) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7341544330120087) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05183424800634384) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7286860942840576) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6711086630821228) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0086426734924316) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.45147620141506195) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.3333258777856827) { + if (maxDuration_2 <= -0.33079037070274353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06571466848254204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2196249961853027) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5864903926849365) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44460032880306244) { + if (maxDuration_2 <= -0.5835758149623871) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (averageDuration_2 <= -0.630709320306778) { + if (averageDuration_2 <= -0.6793220639228821) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23369093984365463) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5561647415161133) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5428372919559479) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.737655371427536) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7158686518669128) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11004803329706192) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4450313597917557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13424039259552956) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5037055611610413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.361900731921196) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7298131585121155) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (averageDuration_2 <= -0.673092782497406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2664700895547867) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.547487884759903) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (maxDuration_2 <= -0.7230182588100433) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12341158092021942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.686084121465683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5287842154502869) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6280176043510437) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21666528284549713) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= -0.6032013297080994) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6914869248867035) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.677620530128479) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31649768352508545) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5158794224262238) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3611845374107361) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5999850630760193) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4770069122314453) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3063729256391525) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19488123804330826) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2643429785966873) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5583013296127319) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (averageDuration_2 <= -0.5972942411899567) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6914103925228119) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7100331485271454) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13424547016620636) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (maxDuration_2 <= -0.5624151825904846) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5656762719154358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.035072119906544685) { + if (maxDuration_2 <= -0.4018147885799408) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5542802214622498) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (maxDuration_2 <= -0.5273146629333496) { + if (averageDuration_2 <= -0.5746402442455292) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13003522530198097) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7048696279525757) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5771014392375946) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.545533299446106) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5922427773475647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5762869417667389) { + if (maxDuration_2 <= -0.5175561606884003) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6963981688022614) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (maxDuration_2 <= -0.5399450957775116) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7043047845363617) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.526005893945694) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2214813232421875) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3367506414651871) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3372919410467148) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41417986154556274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45512649416923523) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (maxDuration_2 <= -0.44399407505989075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5708211660385132) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4630458503961563) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6417805850505829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.623101145029068) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5024031102657318) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8085120916366577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.659948855638504) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.5664370656013489) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (averageDuration_2 <= -0.5570454895496368) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24933598190546036) { + if (maxDuration_2 <= -0.5722824931144714) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4135807454586029) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7357318699359894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5621263980865479) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6200696229934692) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.028598006814718246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5530106127262115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6916634142398834) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43749935925006866) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.49421823024749756) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23797837644815445) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6974388062953949) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5376870632171631) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6072010397911072) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5791914165019989) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835330963135) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6482833027839661) { + if (averageDuration_2 <= -0.5688181519508362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 0.7239611893892288) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5713125467300415) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3368874192237854) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3814961165189743) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3977942019701004) { + if (averageDuration_2 <= -0.5704577565193176) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19602637737989426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3981564790010452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4911867529153824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6242700219154358) { + if (averageDuration_2 <= -0.5163898468017578) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.708705335855484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.44626088440418243) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24538759142160416) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42407001554965973) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5593899190425873) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5236605107784271) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3216704875230789) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44792725145816803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47237007319927216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2337476909160614) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781625390052795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7292173206806183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2668449580669403) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4445071965456009) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.45373593270778656) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21934884041547775) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5852096378803253) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5622245073318481) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.557945728302002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3350065350532532) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5343659818172455) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15526005625724792) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.40183354914188385) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5234972238540649) { + if (maxDuration_2 <= -0.3928743153810501) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616023302078247) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04928279668092728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (numDurations_2 <= 2.1468411684036255) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.337710976600647) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7439393699169159) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8254699110984802) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616238474845886) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21828186511993408) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.730016827583313) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6305622458457947) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47293439507484436) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (averageDuration_2 <= -0.4320108890533447) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4157150834798813) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6388580799102783) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.166086733341217) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.48326602578163147) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32558687031269073) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (maxDuration_2 <= -0.6191702485084534) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.156201720237732) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.161419987678528) { + if (averageDuration_2 <= -0.6748499274253845) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4000852704048157) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { + if (averageDuration_2 <= -0.5494985282421112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5737024247646332) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9177278280258179) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1946990117430687) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8067096173763275) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5572637617588043) { + if (averageDuration_2 <= -0.518149197101593) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16146307438611984) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3563174158334732) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.09413566067814827) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05684150941669941) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5465984344482422) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.253749817609787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2225511223077774) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1072198674082756) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36019499599933624) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6094368696212769) { + if (maxDuration_2 <= -0.3709183484315872) { + if (maxDuration_2 <= -0.6648372411727905) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6555396616458893) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485383749008179) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6975129544734955) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2556520104408264) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7075973153114319) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (maxDuration_2 <= -0.6365318894386292) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + if (maxDuration_2 <= -0.757017195224762) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6804555952548981) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5342106223106384) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.186086654663086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7115999162197113) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7624516487121582) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.6734027564525604) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6529046297073364) { + if (maxDuration_2 <= -0.6433322727680206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.6463054418563843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.080590009689331) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7132413387298584) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5125462412834167) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4400789737701416) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3098171651363373) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6286531686782837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.4446439743041992) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.2406394481658936) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.8750421404838562) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.573187351226807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5961335301399231) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332579910755157) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6125175654888153) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2644031196832657) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (averageDuration_2 <= -0.5024373829364777) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0749278664588928) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (maxDuration_2 <= -0.6097739338874817) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2044304013252258) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.04252815246582) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.132140636444092) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.418075323104858) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7098519206047058) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.2578715980052948) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0072121620178223) { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.077812194824219) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.224177598953247) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (maxDuration_2 <= -0.3920004367828369) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.981752872467041) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23331590741872787) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27022354304790497) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13589466363191605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486179769039154) { + if (maxDuration_2 <= -0.45124760270118713) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482962906360626) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6450034379959106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.00006628036499) { + if (maxDuration_2 <= -0.09045055136084557) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4905432164669037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5110598504543304) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1122801303863525) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8666034936904907) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5144936740398407) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6532392501831055) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5448073446750641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5200567543506622) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5460343062877655) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.553584098815918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.442190483212471) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6955958008766174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6098474264144897) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.601281613111496) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (maxDuration_2 <= -0.35139642655849457) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2707897275686264) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.178974449634552) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5588911771774292) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.051593413576483727) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5986001789569855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9635092914104462) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8787583112716675) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6885001957416534) { + if (maxDuration_2 <= -0.7354182600975037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.44804389774799347) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7328802049160004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8303544819355011) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.331404209136963) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5573742091655731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.4389121532440186) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.517542123794556) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.2484651878476143) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.6181628704071045) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.04611337184906) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25996068120002747) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (maxDuration_2 <= -0.0819484256207943) { + if (averageDuration_2 <= -0.5043905973434448) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.521897166967392) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6094190180301666) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6490458250045776) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617186188697815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6821833848953247) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.529633283615112) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.867992162704468) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7657618224620819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.74553120136261) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7650195360183716) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178307533264) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6021633446216583) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.00006628036499) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7046387195587158) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.165159225463867) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (maxDuration_2 <= -0.6883735656738281) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.579344987869263) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6841802000999451) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.471769332885742) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.183059215545654) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0755597352981567) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2214196920394897) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.835999369621277) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6571447551250458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7094923555850983) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.312984347343445) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.6086798906326294) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (maxDuration_2 <= -0.6234631240367889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575631141663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.5802741050720215) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.576667785644531) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.435875177383423) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34235675632953644) { + if (maxDuration_2 <= -0.5609462559223175) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.399004578590393) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988297700882) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6442541480064392) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (averageDuration_2 <= -0.719832569360733) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.690115809440613) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619999527931213) { + if (averageDuration_2 <= -0.6976645290851593) { + if (averageDuration_2 <= -0.7120301425457001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.237821340560913) { + if (averageDuration_2 <= -0.725535660982132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.449406385421753) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.7316962480545044) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6897306144237518) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8557784855365753) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485684156417847) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613062739372253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.2508179843425751) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { + if (maxDuration_2 <= -0.41614462435245514) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (maxDuration_2 <= -0.4874374270439148) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485253810882568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.158935070037842) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.1120288372039795) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9428106844425201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.9108937978744507) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0890586376190186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.143476486206055) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.850223660469055) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { + if (maxDuration_2 <= -0.3914356827735901) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (averageDuration_2 <= -0.6922805905342102) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.749491214752197) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4815565198659897) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + if (averageDuration_2 <= -0.5128662288188934) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.086333751678467) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473013162613) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9535809755325317) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (averageDuration_2 <= -0.5117494165897369) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.158935070037842) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { + if (maxDuration_2 <= -0.49972596764564514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462536096573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3751400709152222) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (averageDuration_2 <= -0.48433932662010193) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8568262457847595) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18692073225975037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41119202971458435) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.434475600719452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.298130601644516) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.04049695283174515) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.42356060445308685) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.09615419059991837) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3602466583251953) { + if (averageDuration_2 <= -0.5146668255329132) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4387903809547424) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8633034825325012) { + if (averageDuration_2 <= -0.5768377780914307) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.155755639076233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.8113982677459717) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.154330015182495) { + if (maxDuration_2 <= -0.47224630415439606) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.603843688964844) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5238292664289474) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3791850507259369) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { + if (maxDuration_2 <= -0.6105034649372101) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.24946820735931396) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.717059016227722) { + if (maxDuration_2 <= -0.48593053221702576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.556496858596802) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7647639513015747) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4158035516738892) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { + if (maxDuration_2 <= -0.5283782482147217) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4557486176490784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.3048789501190186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.830192446708679) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.227532625198364) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485463321208954) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618495106697083) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.092849254608154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.174108386039734) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623605608940125) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.23927905410528183) { + if (averageDuration_2 <= -0.43246816098690033) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.8958566188812256) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.334665775299072) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310435295105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.08448600769043) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.282440185546875) { + if (maxDuration_2 <= -0.5391396284103394) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.423806831240654) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1980973184108734) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8949843645095825) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3978457450866699) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6440365314483643) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3345415592193604) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { + if (averageDuration_2 <= -0.6847762763500214) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4863396883010864) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622823596000671) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (averageDuration_2 <= -0.41235609352588654) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484157085418701) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9254318177700043) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3456021100282669) { + if (averageDuration_2 <= -0.5058168768882751) { + if (maxDuration_2 <= -0.15823808312416077) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5783149600028992) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5788074433803558) { + if (maxDuration_2 <= -0.4997640401124954) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.537091463804245) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3741144388914108) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.802748203277588) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6712677776813507) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461759626865387) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + if (maxDuration_2 <= -0.3878088891506195) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.646065831184387) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8841458559036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { + if (averageDuration_2 <= -0.6046889126300812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.11321438103914261) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7227886617183685) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5269295275211334) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6453381180763245) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178307533264) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.672433465719223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.6265538930892944) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15253791213035583) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6037487685680389) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6752995252609253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (averageDuration_2 <= -0.5452573299407959) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21048817038536072) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4948030561208725) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29671233892440796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.4877901673316956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0070842504501343) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7821765244007111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5556832253932953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701804161072) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.41785596311092377) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7419655919075012) { + if (maxDuration_2 <= -0.25518954545259476) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2076534628868103) { + if (averageDuration_2 <= -0.5084711015224457) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485871016979218) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4568420052528381) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.9615209102630615) { + if (numDurations_2 <= -0.983494758605957) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.537806510925293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5060377717018127) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13453566655516624) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5448639094829559) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.5524985790252686) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2405078411102295) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.656818687915802) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.522858738899231) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9925618171691895) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.48583482950925827) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5956923961639404) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.066103458404541) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0801680088043213) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.523518979549408) { + if (maxDuration_2 <= -0.18866080790758133) { + if (averageDuration_2 <= -0.603671669960022) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9701417088508606) { + if (numDurations_2 <= 0.15480923652648926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995614923536777) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.191106557846069) { + if (averageDuration_2 <= -0.5661985576152802) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7360992729663849) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819309711456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616394639015198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9784879684448242) { + if (maxDuration_2 <= -0.5637955069541931) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4874650686979294) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08139314502477646) { + if (maxDuration_2 <= -0.5161325931549072) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7858922481536865) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.735918045043945) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5695168673992157) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.370870113372803) { + if (averageDuration_2 <= -0.6768169701099396) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7240088582038879) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9238688945770264) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.6179004907608032) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6577304899692535) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.31682880222797394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.42187587916851044) { + if (maxDuration_2 <= -0.6253246665000916) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5463889837265015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + if (averageDuration_2 <= -0.4222555160522461) { + if (averageDuration_2 <= -0.7240657210350037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.075546860694885) { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.851802408695221) { + if (averageDuration_2 <= -0.6874747574329376) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.641070604324341) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4433693587779999) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31832775473594666) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8450019061565399) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6090219914913177) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2633190006017685) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194464087486267) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6371949315071106) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6100044250488281) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9714998304843903) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3839026689529419) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5379742383956909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3015419691801071) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10017209872603416) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (averageDuration_2 <= -0.13346248120069504) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.155755639076233) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2208210974931717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6068148016929626) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.17705606669187546) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10984431207180023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2003083229064941) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.20772016048431396) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (averageDuration_2 <= -0.18303941190242767) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13353464379906654) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08866410329937935) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.2413341999053955) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5502449572086334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2397812008857727) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.22954095900058746) { + if (averageDuration_2 <= -0.1960652694106102) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3438742607831955) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.043023668229579926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.05132848024368286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (averageDuration_2 <= 0.02000202890485525) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5734407305717468) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1682894602417946) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5522496849298477) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04628022946417332) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (averageDuration_2 <= -0.033020395785570145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144360721111298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (maxDuration_2 <= -0.20898312330245972) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (averageDuration_2 <= -0.2202545702457428) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26031970977783203) { + if (averageDuration_2 <= -0.2403559312224388) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998293876648) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165159225464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25775402784347534) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13644146174192429) { + if (averageDuration_2 <= -0.24034695327281952) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 0.7239612340927124) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960161313414574) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485597431659698) { + if (maxDuration_2 <= -0.1797102764248848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.33079805970191956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5404018759727478) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.625398576259613) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698965072632) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.034901619888842106) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01704788487404585) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (averageDuration_2 <= -0.0679672323167324) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47706516087055206) { + if (numDurations_2 <= 0.43938520550727844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.21765702962875366) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.17289334535598755) { + if (maxDuration_2 <= -0.16121140867471695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37438835203647614) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16241279244422913) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10036905482411385) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.05536891892552376) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.002244919538498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.33512134850025177) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19440588355064392) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.13940123468637466) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.18252447992563248) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21213797479867935) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.10375238955020905) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.126961812376976) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.07220580987632275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1753498539328575) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43600231409072876) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14158286899328232) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (averageDuration_2 <= -0.2507559657096863) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.246923565864563) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24040105193853378) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5125620663166046) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.919897198677063) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841110944747925) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3503604382276535) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18842370063066483) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6082964241504669) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31724025309085846) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.289578378200531) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.1264832243323326) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5683162212371826) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.2389218956232071) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8231029808521271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.2806929498910904) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5070415735244751) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485823631286621) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.09695343300700188) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.38111309707164764) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09066027775406837) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.06424967106431723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.19075536727905273) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12641269341111183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43741314113140106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (averageDuration_2 <= -0.16553089767694473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3957202136516571) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (averageDuration_2 <= -0.2411782667040825) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.298153281211853) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0024429496843367815) { + if (averageDuration_2 <= -0.06986014544963837) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49162955582141876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.1615402102470398) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.20776688307523727) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.276912659406662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (averageDuration_2 <= -0.2622232884168625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.20909453183412552) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07351639494299889) { + if (averageDuration_2 <= -0.2259947806596756) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07129451259970665) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (averageDuration_2 <= -0.2342781275510788) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4840638190507889) { + if (averageDuration_2 <= -0.2690299302339554) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02817050088196993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15083681046962738) { + if (averageDuration_2 <= -0.2679321765899658) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3277653902769089) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3487560451030731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3023988902568817) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.716353565454483) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19543622434139252) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5010741949081421) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2938232570886612) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2082364857196808) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485513687133789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485261857509613) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21113988012075424) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26953834295272827) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484966218471527) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1986444666981697) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07856107130646706) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4742172807455063) { + if (averageDuration_2 <= -0.10754148662090302) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01990731619298458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.058113276958465576) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.011581110768020153) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.20217006653547287) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841110944747925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.06753522902727127) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.12285849452018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485546171665192) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5749931037425995) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.21451514214277267) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485018074512482) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.28631116449832916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.07770555093884468) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.30396661162376404) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3798131197690964) { + if (averageDuration_2 <= -0.1773580014705658) { + if (maxDuration_2 <= -0.25428277999162674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5419613420963287) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.16011209785938263) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.07088297978043556) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5716511011123657) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.22142869979143143) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6807559132575989) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18290074914693832) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485170066356659) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.31694912910461426) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38472796976566315) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.36404065787792206) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (averageDuration_2 <= -0.2260044664144516) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.25604359805583954) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15153738111257553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09020838141441345) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4232677221298218) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5538188219070435) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3895184397697449) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25027691572904587) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.346693679690361) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.584574431180954) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (averageDuration_2 <= -0.20905528217554092) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17459945380687714) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (maxDuration_2 <= -0.17008856683969498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.43513740599155426) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (averageDuration_2 <= -0.25282905995845795) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485954761505127) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718024134635925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.1181785874068737) { + if (maxDuration_2 <= -0.3301217705011368) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06744236499071121) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20490463823080063) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27727271616458893) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5477399230003357) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (maxDuration_2 <= -0.1728212684392929) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.25732527673244476) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6492643356323242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28608469665050507) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617000818252563) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.457713544368744) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (maxDuration_2 <= -0.23593854159116745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485789656639099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.37850624322891235) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5710813403129578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1906251907348633) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4352436065673828) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5594193637371063) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.6307660341262817) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.328541338443756) { + if (maxDuration_2 <= -0.34970705211162567) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0739621818065643) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8508365154266357) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.157551884651184) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5328285396099091) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9766682386398315) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4294387102127075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.22442620992660522) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.27244462072849274) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5022991895675659) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (maxDuration_2 <= -0.2616579681634903) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2291715145111084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.443066120147705) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.487790107727051) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4285300374031067) { + if (averageDuration_2 <= -0.11506064236164093) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.4668562412261963) { + if (averageDuration_2 <= -0.3087059408426285) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3930707573890686) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5961965918540955) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.15266720950603485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.4125157594680786) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4097729921340942) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (averageDuration_2 <= -0.24292107671499252) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2762174680829048) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404849529266) { + if (averageDuration_2 <= -0.09198318794369698) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.724435418844223) { + if (maxDuration_2 <= -0.2396666184067726) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (averageDuration_2 <= -0.2190263420343399) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3897310942411423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (maxDuration_2 <= -0.3375881612300873) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= -0.1976470947265625) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (averageDuration_2 <= -0.28265000879764557) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.010598020628094673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (averageDuration_2 <= -0.2693638950586319) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310733318329) { + if (averageDuration_2 <= -0.10486993938684464) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (averageDuration_2 <= -0.21682287752628326) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.528399646282196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3044518083333969) { + if (maxDuration_2 <= -0.2164848893880844) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (averageDuration_2 <= -0.25356268882751465) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (averageDuration_2 <= -0.1160062737762928) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6002986431121826) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5863257050514221) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.2851201593875885) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= -0.28363431990146637) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.453575611114502) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2297377586364746) { + if (averageDuration_2 <= -0.19054347276687622) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.6065900325775146) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5402499735355377) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4226353168487549) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936677023768425) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5699305534362793) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35360656678676605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508574008942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (averageDuration_2 <= -0.020353716798126698) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4444212913513184) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0925476551055908) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331027030945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.13808871060609818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206787645817) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.5647449493408203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.17935819923877716) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485765516757965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22289638966321945) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.4071969985961914) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5992768108844757) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47795867919921875) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10518208518624306) { + if (averageDuration_2 <= -0.2870832085609436) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2518677115440369) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.714409112930298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.432702660560608) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0970265865325928) { + if (averageDuration_2 <= -0.2447943165898323) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.44806969165802) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2379305958747864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4292091727256775) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5748830735683441) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13580286130309105) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.2719774842262268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.2567959576845169) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41412487626075745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4565791487693787) { + if (maxDuration_2 <= -0.3124081641435623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3445320874452591) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620537757873535) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2745468467473984) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.25125275552272797) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2406897321343422) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9199509620666504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03406105190515518) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612095355987549) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (averageDuration_2 <= -0.14517241716384888) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.09434983134269714) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.22163639217615128) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.17004309594631195) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6812559366226196) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1844562441110611) { + if (maxDuration_2 <= -0.452139288187027) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5587128698825836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3642895817756653) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2985364645719528) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.46517783403396606) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.2806835174560547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32175226509571075) { + if (averageDuration_2 <= -0.30321893095970154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.21648497134447098) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6001963019371033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (averageDuration_2 <= -0.15420497953891754) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.359214186668396) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617977142333984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1858297921717167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617742896080017) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13072708249092102) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36913350224494934) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1784394308924675) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (maxDuration_2 <= -0.2780419886112213) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.510258823633194) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.3669004440307617) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615329504013062) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.2831329107284546) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6901179552078247) { + if (averageDuration_2 <= -0.2523527592420578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5350112020969391) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (averageDuration_2 <= -0.26994237303733826) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2007369995117188) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0792827308177948) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.588455319404602) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.10004199296236038) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.400429904460907) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5949993133544922) { + if (averageDuration_2 <= -0.24799761921167374) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7686214447021484) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.146611124277115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.14777786284685135) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.729569673538208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.7307084798812866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.346752166748047) { + if (averageDuration_2 <= -0.22678132355213165) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3240416944026947) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.28348465263843536) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2106016278266907) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0073401182889938354) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6136592328548431) { + if (averageDuration_2 <= -0.29494817554950714) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5074905455112457) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4343758821487427) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4531906247138977) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.22801128029823303) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8518567085266113) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2421379685401917) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485286295413971) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5447190701961517) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31182965636253357) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3542330414056778) { + if (averageDuration_2 <= -0.23049961775541306) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.25031592696905136) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.22282475978136063) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (averageDuration_2 <= -0.2823459953069687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485852241516113) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.2620607614517212) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (averageDuration_2 <= -0.13310864567756653) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461574912071228) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2264362573623657) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02741278090979904) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616150259971619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.2624937742948532) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8295444846153259) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.08784888312220573) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.316119909286499) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9311985075473785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4269055426120758) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42138414084911346) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3191892504692078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36560143530368805) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.09894521534442902) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4351820349693298) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6693859994411469) { + if (averageDuration_2 <= -0.21764829754829407) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.13483598828315735) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27366556227207184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.012071079108864069) { + if (averageDuration_2 <= -0.1938987895846367) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.19929425418376923) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7075349986553192) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.1362542137503624) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.14084868878126144) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284968852997) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8470544517040253) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.0445276498794556) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4207622408866882) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4650612026453018) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.05768261104822159) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7152725756168365) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (averageDuration_2 <= -0.014967279508709908) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08551564812660217) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.23219355940818787) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (maxDuration_2 <= -0.06512873619794846) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (averageDuration_2 <= 0.033267874270677567) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.22189614176750183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.080590009689331) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20673025771975517) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485131919384003) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504844069480896) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4358607083559036) { + if (averageDuration_2 <= -0.036771563813090324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.13137878477573395) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.4314171075820923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.19815204292535782) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18841815739870071) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.05795177444815636) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.07658972963690758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612564444541931) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11745024472475052) { + if (averageDuration_2 <= -0.2065293788909912) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4466978907585144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.024998968467116356) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (maxDuration_2 <= -0.11620554700493813) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.588432788848877) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616785645484924) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5503934621810913) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.05575621500611305) { + if (maxDuration_2 <= -0.09128132835030556) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15631073713302612) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482256293296814) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5813577771186829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (averageDuration_2 <= -0.15407860279083252) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (averageDuration_2 <= -0.22397392988204956) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7437497973442078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611929059028625) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.12891700863838196) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03910523280501366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.16688719391822815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6678706109523773) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (averageDuration_2 <= -0.21712301671504974) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.28221355378627777) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3758256137371063) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.8622652292251587) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7440966665744781) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44211241602897644) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2492470145225525) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485499978065491) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.03102345857769251) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.040098683908581734) { + if (maxDuration_2 <= -0.0508721973747015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5129373222589493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614078998565674) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.0904808733612299) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460499584675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.396992802619934) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5411615967750549) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2793646976351738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= 0.02263886108994484) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3577922582626343) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (maxDuration_2 <= -0.030808256939053535) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5823568999767303) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26996055990457535) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16085726767778397) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.13020127266645432) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4549474120140076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (maxDuration_2 <= -0.121772401034832) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.586359828710556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1399371027946472) { + if (averageDuration_2 <= -0.24770252406597137) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5978710353374481) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7788397669792175) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2843915671110153) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3708546161651611) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300742030143738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.5079384446144104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.056241512298583984) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9165481328964233) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9062473177909851) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.648976445198059) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.162411332130432) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.16756846755743027) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.0812260508537292) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7751853168010712) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.7158921957015991) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5393354296684265) { + if (averageDuration_2 <= -0.21893543750047684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5401894152164459) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.0243793725967407) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2693729996681213) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8634464740753174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.634629100561142) { + if (averageDuration_2 <= -0.22250784933567047) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (averageDuration_2 <= -0.23197568953037262) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (maxDuration_2 <= -0.2030058354139328) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4586394429206848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3186301589012146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.380498468875885) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940378189087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3795580714941025) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5412280559539795) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (averageDuration_2 <= -0.18513117730617523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36531537771224976) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (maxDuration_2 <= -0.33743615448474884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485586702823639) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (maxDuration_2 <= -0.19888780266046524) { + if (maxDuration_2 <= -0.3716072142124176) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (maxDuration_2 <= -0.19001320004463196) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= -0.2656038850545883) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4481752514839172) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (averageDuration_2 <= -0.21634289622306824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (averageDuration_2 <= -0.1657920405268669) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3529024124145508) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4170385599136353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4484801292419434) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04477715119719505) { + if (averageDuration_2 <= -0.23944104462862015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { + if (averageDuration_2 <= -0.3071551024913788) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.1842944175004959) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1600455641746521) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3908514529466629) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.2430381253361702) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.12002952769398689) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6083272695541382) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.24495743215084076) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1964828372001648) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6917512118816376) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2723228335380554) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28074170649051666) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.31292930245399475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13006144016981125) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2506812959909439) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616023302078247) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3963238000869751) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.10480842366814613) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (averageDuration_2 <= -0.13632949441671371) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618250727653503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.16428355872631073) { + if (averageDuration_2 <= -0.22739523649215698) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486131191253662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4201867580413818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37726353108882904) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5813480317592621) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618387818336487) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4517005681991577) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (maxDuration_2 <= -0.16814082115888596) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (maxDuration_2 <= -0.24188528954982758) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.439121663570404) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (averageDuration_2 <= -0.26898907124996185) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2259418368339539) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1352650597691536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9594480693340302) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41071929037570953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4982703924179077) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.24109670519828796) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49002355337142944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3251563608646393) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4896641969680786) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461400032043457) { + if (averageDuration_2 <= -0.23131374269723892) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6899430751800537) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.0399842020124197) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (averageDuration_2 <= -0.20628903061151505) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39591050148010254) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.22710911184549332) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18114004284143448) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484611868858337) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12669262662529945) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.030869334936142) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7406226694583893) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03943234868347645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6701188683509827) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.23517612367868423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.08775846287608147) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5287817716598511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22426453977823257) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (averageDuration_2 <= -0.19299542158842087) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21874354034662247) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.20406494289636612) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40689530968666077) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485093772411346) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07386618852615356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (averageDuration_2 <= -0.2352519929409027) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.293758749961853) { + if (averageDuration_2 <= -0.3226594775915146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1193835623562336) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18289048224687576) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.20736579596996307) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (averageDuration_2 <= -0.25438959896564484) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.2929645776748657) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0896867513656616) { + if (averageDuration_2 <= -0.2406178042292595) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6146548390388489) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2596495449542999) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.410082682967186) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485668063163757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7264962196350098) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478698492050171) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18027283251285553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.24800492823123932) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8504891991615295) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4846348911523819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.008742198580875993) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.06665969640016556) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3183627128601074) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.33321669697761536) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.16020051389932632) { + if (averageDuration_2 <= -0.26541364192962646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.12983133643865585) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2312689796090126) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7319779396057129) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7480913400650024) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11754176393151283) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35916490852832794) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3704606592655182) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613902568817139) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485527396202087) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3520054519176483) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4934031218290329) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4231228828430176) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45178520679473877) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (averageDuration_2 <= -0.1166103146970272) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0165472328662872) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16139467805624008) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3379719853401184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (averageDuration_2 <= -0.21127159148454666) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3325408399105072) { + if (averageDuration_2 <= -0.0858023576438427) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6754916608333588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618290066719055) { + if (averageDuration_2 <= -0.22487758845090866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13622060418128967) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615837335586548) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3433229774236679) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2580515518784523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9441151916980743) { + if (averageDuration_2 <= -0.28417322039604187) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2008199691772461) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03790028393268585) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15835338085889816) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615886807441711) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08280551806092262) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5418338179588318) { + if (averageDuration_2 <= -0.01565258577466011) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (averageDuration_2 <= -0.05734695680439472) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3965482711791992) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.13016829639673233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05981086380779743) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.16457747668027878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484904527664185) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4898931384086609) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33012065291404724) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3854826092720032) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (averageDuration_2 <= -0.13765016943216324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7655328810214996) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0926169753074646) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.04015974886715412) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7409540414810181) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43047793209552765) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.10118158906698227) { + if (averageDuration_2 <= -0.1491527557373047) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.9310524463653564) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613492488861084) { + if (maxDuration_2 <= -0.08699353039264679) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470267772675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.1477046236395836) { + if (averageDuration_2 <= -0.12142528593540192) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619531035423279) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21404454857110977) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20802363753318787) { + if (averageDuration_2 <= -0.15815559774637222) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616326093673706) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.07535824552178383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.08234081417322159) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07672958448529243) { + if (averageDuration_2 <= -0.3150785565376282) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.09115253388881683) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.601638913154602) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.3450782895088196) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (maxDuration_2 <= -0.17468538880348206) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4534631967544556) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28456349670886993) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44314736127853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6193670630455017) { + if (averageDuration_2 <= -0.25351032614707947) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616873264312744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.07545875012874603) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.26465658843517303) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5848534405231476) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (maxDuration_2 <= -0.2500811219215393) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486188113689423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26730862259864807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.015263928566128016) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6499199569225311) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.401174932718277) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.19026003032922745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.4668562412261963) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (averageDuration_2 <= -0.19253239035606384) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862932682037) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03999907709658146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2945640832185745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5750867426395416) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28576844930648804) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1848509982228279) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5452868640422821) { + if (maxDuration_2 <= -0.29307354986667633) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.20175477117300034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4159608781337738) { + if (averageDuration_2 <= -0.22115132957696915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4901169687509537) { + if (averageDuration_2 <= -0.20688879489898682) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5909576117992401) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3679952770471573) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514787554741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28070971369743347) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620283246040344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09204968623816967) { + if (averageDuration_2 <= -0.2580084949731827) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.078460942953825) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.28613902628421783) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4533283710479736) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6172909438610077) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.342580109834671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.25963789224624634) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.19963230937719345) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5804057717323303) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617292881011963) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6116690337657928) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10007137805223465) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.05522541329264641) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.08869535103440285) { + if (maxDuration_2 <= -0.15201012790203094) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.09147687628865242) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5388723015785217) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3719324320554733) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1294299215078354) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.1197817362844944) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43867380917072296) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5945817828178406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5403359830379486) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (averageDuration_2 <= -0.16917476058006287) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6164050400257111) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485139966011047) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09939930215477943) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.22089427709579468) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617684483528137) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.31761622428894043) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5430162847042084) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588007539511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.2188083454966545) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2873704582452774) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03555995970964432) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8477738797664642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.1645950973033905) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.768029272556305) { + if (maxDuration_2 <= -0.2014787644147873) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3919132500886917) { + if (averageDuration_2 <= -0.3162904977798462) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25934740900993347) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (averageDuration_2 <= -0.5118111073970795) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.28144341707229614) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1390957087278366) { + if (maxDuration_2 <= -0.37317243218421936) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05752851255238056) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + if (cpuCoreIdleTimesPercentage_6_2 <= -5.205564856529236) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3551851958036423) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (averageDuration_2 <= -0.4312569797039032) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.1149210929870605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4867181330919266) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.28120526671409607) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37684209644794464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615749716758728) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2622058242559433) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4666135311126709) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.42862044274806976) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5380691289901733) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.37636078894138336) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2993045449256897) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334689199924469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14507585763931274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.32905812561511993) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.48323559761047363) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5112777054309845) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.45919446647167206) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8782568871974945) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461593508720398) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06219152361154556) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08275226503610611) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.45044487714767456) { + if (averageDuration_2 <= -0.6053622364997864) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4473549723625183) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33843834698200226) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4569520801305771) { + if (averageDuration_2 <= -0.6220126152038574) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2229373455047607) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3298584520816803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6121294498443604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 0.15480923652648926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5428920090198517) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08234952762722969) { + if (maxDuration_2 <= -0.6117191314697266) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6511207520961761) { + if (numDurations_2 <= -0.4143427312374115) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8239282071590424) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.516137599945068) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.520334839820862) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5135570168495178) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5687973499298096) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.651829332113266) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1319883093237877) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15393465012311935) { + if (averageDuration_2 <= -0.6868147552013397) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2533997893333435) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.198177814483643) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.059118157252669334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6342499852180481) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7187130451202393) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06997130066156387) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10643527284264565) { + if (numDurations_2 <= -0.9834946841001511) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6754916310310364) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6171745955944061) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8747268617153168) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.6741044223308563) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.523481369018555) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601464867591858) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 0.43938517570495605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6768707036972046) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { + if (averageDuration_2 <= -0.6091971397399902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10454852506518364) { + if (averageDuration_2 <= -0.4680220037698746) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9243354201316833) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.875303789973259) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06410611793398857) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.23677925765514374) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5737024396657944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20792997628450394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4499615281820297) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.004384718486107886) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.33594565093517303) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06273120269179344) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0682937353849411) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3921428471803665) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35612012445926666) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (averageDuration_2 <= -0.47856755554676056) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3884730637073517) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1758318543434143) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5458981096744537) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.010261744144372642) { + if (maxDuration_2 <= -0.4163549244403839) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1433163583278656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.14197072014212608) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.5280866622924805) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23931897431612015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4471777081489563) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4867308884859085) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23659098893404007) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (maxDuration_2 <= -0.37142235040664673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04112440347671509) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3290334641933441) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5476982891559601) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11801374331116676) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617782235145569) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3986017107963562) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618172645568848) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06244852766394615) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.057407304644584656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0525869727134705) { + if (maxDuration_2 <= -0.3782200962305069) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5356264114379883) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643927812576294) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.88081955909729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.2626097202301025) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2874188423156738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.328498363494873) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6285011768341064) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.2807519882917404) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14924612641334534) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6401647925376892) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4391323328018188) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.933671712875366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.016247338615357876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.267539143562317) { + if (maxDuration_2 <= -0.23914239555597305) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1187252402305603) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (averageDuration_2 <= -0.4838390201330185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.2481638342142105) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.506764680147171) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.41790224611759186) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.45313355326652527) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4303327798843384) { + if (averageDuration_2 <= -0.5682932436466217) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03880126588046551) { + if (maxDuration_2 <= -0.29738421738147736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.728938341140747) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40385177731513977) { + if (averageDuration_2 <= -0.5442897081375122) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5313072502613068) { + if (maxDuration_2 <= -0.5931037962436676) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4510390758514404) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.36946453154087067) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461394190788269) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12900884449481964) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4595877528190613) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= -0.6007451415061951) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620595574378967) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.058661652728915215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6119883358478546) { + if (averageDuration_2 <= -0.5737406313419342) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2734104990959167) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16778968274593353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6981249451637268) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117392778396606) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.45227643847465515) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39174917340278625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9606459438800812) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.010100342333316803) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044002512469888) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19247598201036453) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643943786621) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.48200465738773346) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (averageDuration_2 <= -0.7134470343589783) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21485445648431778) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.406023770570755) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.49757325649261475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2517111152410507) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27228793501853943) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8985591530799866) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5433522164821625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.31560441851615906) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18187187612056732) { + if (averageDuration_2 <= -0.4707178622484207) { + if (maxDuration_2 <= -0.4656512290239334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06485873274505138) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04570912569761276) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4484865665435791) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26855531334877014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.36062803864479065) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7002528607845306) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5120779573917389) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (averageDuration_2 <= -0.35705868899822235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19628722965717316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.033889889717102) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4548403024673462) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2508612722158432) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.513828694820404) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5002696365118027) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19454072415828705) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1795601844787598) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (averageDuration_2 <= -0.3222580850124359) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4727402627468109) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5434605479240417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.020178772509098053) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3397738039493561) { + if (maxDuration_2 <= -0.513969898223877) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.366422101855278) { + if (averageDuration_2 <= -0.35798439383506775) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (maxDuration_2 <= -0.27191032469272614) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (maxDuration_2 <= -0.2489742711186409) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1325666606426239) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5525524318218231) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.110644340515137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621328711509705) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2472827434539795) { + if (maxDuration_2 <= -0.6596148610115051) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0810356140136719) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (maxDuration_2 <= -0.6446768641471863) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4371659755706787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7204834520816803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.622090995311737) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (averageDuration_2 <= -0.3919198662042618) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.028514383360743523) { + if (averageDuration_2 <= -0.5272644460201263) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.03393502160906792) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.7104121446609497) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3730001747608185) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.52136766910553) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31930628418922424) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5565827488899231) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.25013040006160736) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.1604703664779663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.29069268703460693) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.2566462755203247) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.071472942829132) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12892761826515198) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (maxDuration_2 <= -0.5506558120250702) { + if (averageDuration_2 <= -0.565261036157608) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1371820904314518) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2696340084075928) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.39274491369724274) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (averageDuration_2 <= -0.32923445105552673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614605903625488) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.1934890747070312) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4650067985057831) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2133428454399109) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.36533886194229126) { + if (averageDuration_2 <= -0.6627611815929413) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35516420006752014) { + if (averageDuration_2 <= -0.4147626906633377) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (numDurations_2 <= 1.293113186955452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16128583252429962) { + if (averageDuration_2 <= -0.44746164977550507) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.029428482055664) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9049203991889954) { + if (averageDuration_2 <= -0.5005944967269897) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2944958209991455) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2503594681620598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.29451368749141693) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461827039718628) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.326260566711426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.28546807169914246) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392869949341) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4177210032939911) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5054148137569427) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (maxDuration_2 <= -0.48509715497493744) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.016302227973938) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4159824997186661) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616697430610657) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24867316335439682) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.32630273699760437) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4204780161380768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4214911460876465) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4535132348537445) { + if (maxDuration_2 <= -0.6082468330860138) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.5203347206115723) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3382478505373001) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4327164590358734) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.4984925836324692) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03565324656665325) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617606401443481) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614351987838745) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.04049695748835802) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4622689038515091) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.18598419427871704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.36499546468257904) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899798870087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2291945442557335) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (maxDuration_2 <= -0.38332855701446533) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1920124813914299) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3640940934419632) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461581826210022) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08722826093435287) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20403236895799637) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.872782826423645) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6383220553398132) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2833772450685501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33082449436187744) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.136162631213665) { + if (averageDuration_2 <= -0.33991654217243195) { + if (maxDuration_2 <= -0.4661094844341278) { + if (averageDuration_2 <= -0.3635009080171585) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46144700050354) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3455488532781601) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.30242931842803955) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.45089127123355865) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3600654602050781) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36681056022644043) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (averageDuration_2 <= -0.6577690243721008) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3646232932806015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4302535653114319) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4072736501693726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3670215606689453) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4437950253486633) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4781753867864609) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5006100237369537) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5006630420684814) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8827948570251465) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4629302024841309) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462306797504425) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10430236160755157) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9328933656215668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39335161447525024) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3666815757751465) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (averageDuration_2 <= -0.5932608246803284) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.264214992523193) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3734450936317444) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6040298044681549) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14462585002183914) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.474169611930847) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.337710976600647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565295755863) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815459728241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606408476829529) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06614914163947105) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6850340664386749) { + if (maxDuration_2 <= -0.36109407246112823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4436591863632202) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.37817035615444183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6482833027839661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5045659244060516) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (maxDuration_2 <= -0.4038102626800537) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.1465429225936532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (maxDuration_2 <= -0.37006227672100067) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0018542110919952) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12457386404275894) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461931586265564) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4169829934835434) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.34106379747390747) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1267523169517517) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2627514600753784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0567401722073555) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581474900245667) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.348087415099144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.894984394311905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.45725272595882416) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461747944355011) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2559414878487587) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (maxDuration_2 <= -0.5351456105709076) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48940515518188477) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461400032043457) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09254208952188492) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09236176311969757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5329746305942535) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.191304624080658) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.15119463950395584) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.812464714050293) { + if (maxDuration_2 <= -0.25411050021648407) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3614371120929718) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.31057946383953094) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6290831565856934) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08403028920292854) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12471647933125496) { + if (maxDuration_2 <= -0.34866863489151) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5138756781816483) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.22718121856451035) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08122313022613525) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16704006493091583) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306547224521637) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9250051379203796) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.47468680143356323) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25981275737285614) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (averageDuration_2 <= -0.1449161395430565) { + if (averageDuration_2 <= -0.22330693900585175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000302791595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8776583075523376) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3378542512655258) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4328937381505966) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26350855827331543) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6971963346004486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.21226287633180618) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.24943159520626068) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29946811497211456) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07928066328167915) { + if (averageDuration_2 <= -0.2663479745388031) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13196203112602234) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (averageDuration_2 <= -0.23652255535125732) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.15828602015972137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.20850521326065063) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03561710566282272) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.036067111417651176) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.36404065787792206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17915936559438705) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3817836493253708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2701772451400757) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.26247355341911316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13662757724523544) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.043676257133484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.190030999481678) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0217979708686471) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.7767811566591263) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2021644040942192) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32871532440185547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3294471204280853) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7766812145709991) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15424585714936256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 0.4393852949142456) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0907236859202385) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (maxDuration_2 <= -0.35182175040245056) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3771457076072693) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (maxDuration_2 <= -0.2383040264248848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5552991330623627) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33037421107292175) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09878694266080856) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13024823367595673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5541455149650574) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13734819740056992) { + if (averageDuration_2 <= -0.18964356929063797) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6495687067508698) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04424252547323704) { + if (maxDuration_2 <= -0.342093825340271) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24154941737651825) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32605475187301636) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.30175653100013733) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28368079662323) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3491670787334442) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10000893846154213) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13642826676368713) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.26673850417137146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7134557366371155) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.002630658447742462) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2759010195732117) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.638838529586792) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7455261647701263) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948375284671783) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34089985489845276) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5495878458023071) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107351958751678) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1686181724071503) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.05036983825266361) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.28266914188861847) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (averageDuration_2 <= -0.18197216093540192) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2663658559322357) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10765547677874565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4108458161354065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5754210352897644) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620370864868164) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1557555198669434) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4400380849838257) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5953681766986847) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.5280866622924805) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09458231925964355) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (maxDuration_2 <= -0.29755397140979767) { + if (averageDuration_2 <= -0.2869718074798584) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2443152293562889) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02348506823182106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615495800971985) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41980235278606415) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (maxDuration_2 <= -0.21035583317279816) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1729447916150093) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5453493893146515) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4314427375793457) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1434735655784607) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05335359834134579) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856560230255) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.41251610219478607) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31802448630332947) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461624801158905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.2729891985654831) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (maxDuration_2 <= -0.37541136145591736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2203487530350685) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.2847333699464798) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06934653967618942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613766074180603) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1560530886054039) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.24257842451334) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.11316731944680214) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.31216245889663696) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4353823065757751) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5603935122489929) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (maxDuration_2 <= -0.3513633608818054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.29338543117046356) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.740801215171814) { + if (averageDuration_2 <= -0.2829168736934662) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3116227835416794) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09590877592563629) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.29311196506023407) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3994452357292175) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5841034054756165) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687222957611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.021249395795166492) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14316435158252716) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618173241615295) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07204516977071762) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4382256269454956) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.22508987039327621) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2698106914758682) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.28026944398880005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04698444716632366) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2575254589319229) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1808619201183319) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4575757384300232) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.045653900131583214) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (maxDuration_2 <= -0.2499670460820198) { + if (averageDuration_2 <= -0.18946100026369095) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (averageDuration_2 <= -0.24712148308753967) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5372239649295807) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.30304479598999023) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560847997665405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5502709448337555) { + if (maxDuration_2 <= -0.28240838646888733) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3427748382091522) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35559920966625214) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5373333692550659) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08361831866204739) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= -0.27015531063079834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04129335843026638) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10523811355233192) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6377881765365601) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24946270138025284) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.334667682647705) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792978852987289) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2664355933666229) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617391228675842) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.28832489252090454) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.2993554025888443) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1058686971664429) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3149110078811646) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8518567085266113) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9355696141719818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.21410495042800903) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.817373812198639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (averageDuration_2 <= -0.158875972032547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616003632545471) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1330556496977806) { + if (maxDuration_2 <= -0.260244682431221) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08150799944996834) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5537188649177551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3962578624486923) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2227640077471733) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028930187225342) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.20954284816980362) { + if (maxDuration_2 <= -0.33716002106666565) { + if (averageDuration_2 <= -0.2667088210582733) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.28964002430438995) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2987538129091263) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01611737348139286) { + if (maxDuration_2 <= -0.2452893704175949) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3818919658660889) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.25077225267887115) { + if (maxDuration_2 <= -0.3589082509279251) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6035719513893127) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4338373839855194) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (averageDuration_2 <= -0.08623037859797478) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1699594184756279) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4276142865419388) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.34151895344257355) { + if (averageDuration_2 <= -0.2682454586029053) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4812910556793213) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (maxDuration_2 <= -0.36724843084812164) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.23690717667341232) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3890136033296585) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.690115809440613) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (averageDuration_2 <= -0.2755594551563263) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43015794456005096) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3787899315357208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.25005583465099335) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (averageDuration_2 <= -0.1868828982114792) { + if (averageDuration_2 <= -0.22986715286970139) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15699046850204468) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836058139801025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.21015457808971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.33441968262195587) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (maxDuration_2 <= -0.3852507770061493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4224183559417725) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5176974833011627) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08966985088773072) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6776900589466095) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611049890518188) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2811780422925949) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (maxDuration_2 <= -0.38816843926906586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.28374050557613373) { + if (maxDuration_2 <= -0.3160957545042038) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0004646275192499161) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660902678967) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2642075717449188) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.01496067875996232) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3006367087364197) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4942189007997513) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (averageDuration_2 <= -0.24844079464673996) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.27477996051311493) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2228635922074318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617244601249695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.7505510747432709) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3143675327301025) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9502524733543396) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461689293384552) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670424342155) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8916389048099518) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5364645272493362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185645341873) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7543280124664307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611098766326904) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.059363359585404396) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461599349975586) { + if (averageDuration_2 <= -0.6790809035301208) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2985755354166031) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6182836592197418) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4356045722961426) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5395924150943756) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.03074631467461586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.6132869720458984) { + if (maxDuration_2 <= -0.47133949398994446) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5546479970216751) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.370543122291565) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (averageDuration_2 <= -0.630023717880249) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576099514961243) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5249413549900055) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0028034448623657) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461667776107788) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.764528274536133) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3183400332927704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5434842705726624) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580029129981995) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1434106826782227) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.6065900325775146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0646941661834717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7869033813476562) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.232851505279541) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3226674795150757) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.31898969411849976) { + if (maxDuration_2 <= -0.6490029394626617) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7960852682590485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.008537232875824) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.482079982757568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.815155506134033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4758663922548294) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7877449095249176) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6996400356292725) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.8208415508270264) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0184154212474823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9191526770591736) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8188257217407227) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6287179291248322) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8740872144699097) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4676833748817444) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5807949900627136) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16108286380767822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3997823596000671) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2287803292274475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8221323192119598) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.47513236105442047) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14660311862826347) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.828829526901245) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.655461072921753) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5665739178657532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4821932911872864) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.88081955909729) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3127616047859192) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.35195110738277435) { + if (averageDuration_2 <= -0.61421138048172) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.436114549636841) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6879672110080719) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.622090995311737) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2738459706306458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0971235036849976) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2587442994117737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622560143470764) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.670087605714798) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2244835495948792) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (averageDuration_2 <= -0.7222028970718384) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4838865399360657) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.734078288078308) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (averageDuration_2 <= -0.6300341784954071) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.44120562076568604) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462140679359436) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.496540606021881) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.247114419937134) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.5647449493408203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.058659059926867485) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { + if (maxDuration_2 <= -0.5669639706611633) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6905273497104645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5547195971012115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.136928081512451) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4591410160064697) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5795921385288239) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6988271772861481) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6581415235996246) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6888639330863953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5059231221675873) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070023775100708) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8495564758777618) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0048209428787231) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5768853425979614) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.603390395641327) { + if (maxDuration_2 <= -0.49372856318950653) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854621887207) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1540033221244812) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1784498393535614) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04572329297661781) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.6396484971046448) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.778661012649536) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6601682603359222) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998293876648) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4589807987213135) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20123599469661713) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (averageDuration_2 <= -0.6948885321617126) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3350065350532532) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5481290519237518) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.058113276958465576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6834675371646881) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.0163023471832275) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841007590294) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6384719014167786) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5362087786197662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.407145231962204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6544688940048218) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618250727653503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (averageDuration_2 <= -0.36733441054821014) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0632526278495789) { + if (averageDuration_2 <= -0.4063328057527542) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5737687647342682) { + if (maxDuration_2 <= -0.6469311714172363) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21543563157320023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.6878583431243896) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + if (averageDuration_2 <= -0.5650017857551575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6085500121116638) { + if (averageDuration_2 <= -0.4131365269422531) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8982323706150055) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8271262049674988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17338982969522476) { + if (numDurations_2 <= 1.5776892304420471) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9737967848777771) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.806822419166565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6704152822494507) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31695446372032166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.46907684206962585) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.447493553161621) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.267017900943756) { + if (averageDuration_2 <= -0.4792470335960388) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5922571420669556) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9536126255989075) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7248521447181702) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2896692752838135) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8189626932144165) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2155027389526367) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5965052843093872) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.241388201713562) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0623801946640015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1686182022094727) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.2249561548233032) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.11029172502458096) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.6819607615470886) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.547453373670578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.781357765197754) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5529413521289825) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0172525644302368) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.1049726009368896) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0982537865638733) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2796006202697754) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4795931577682495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.627035915851593) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4670807719230652) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9341025948524475) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6163031160831451) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2304048538208008) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.002803385257721) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 0.15480925142765045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5460585653781891) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5877141952514648) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4636141061782837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409679770469666) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8775232434272766) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1428144872188568) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6205661594867706) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.5460230112075806) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (maxDuration_2 <= -0.5453853607177734) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (averageDuration_2 <= -0.4898129105567932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5202332735061646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08590482175350189) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4735721349716187) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7883439362049103) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2934679985046387) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.776781141757965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0674948692321777) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4504905343055725) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06097376253455877) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.38994139432907104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16669779270887375) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.461654543876648) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4495493173599243) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7284773588180542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8173737525939941) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2710488438606262) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0301701426506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9436168670654297) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.024668037891388) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8786739110946655) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { + if (averageDuration_2 <= -0.2954387366771698) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1466110944747925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5399353504180908) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.376254677772522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4495320320129395) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9921256005764008) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3412681818008423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2610379755496979) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620527625083923) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8954995274543762) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13854463398456573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + if (maxDuration_2 <= -0.3642979711294174) { + if (averageDuration_2 <= -0.3590235412120819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { + if (averageDuration_2 <= -0.315903440117836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8220312893390656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5989179015159607) { + if (maxDuration_2 <= -0.4185810983181) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0728518962860107) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.28675179183483124) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20619340240955353) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5215759873390198) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7575733959674835) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0697360672056675) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18249281495809555) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5960299670696259) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9591535031795502) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.013704310171306133) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0181790590286255) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960221290588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11831073090434074) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (maxDuration_2 <= -0.41793787479400635) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5521375834941864) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.291418969631195) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.677155613899231) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680707424879074) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.310835838317871) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0546895265579224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9650880694389343) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.988897979259491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798433244228363) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.11029172502458096) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3510091155767441) { + if (maxDuration_2 <= -0.58884397149086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2812066376209259) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29360024631023407) { + if (maxDuration_2 <= -0.6208974421024323) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0604872703552246) { + if (maxDuration_2 <= -0.3946142792701721) { + if (maxDuration_2 <= -0.41402484476566315) { + if (maxDuration_2 <= -0.594585508108139) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.009416103363037) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.174602508544922) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.43753771483898163) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3217187076807022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5630825161933899) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5096820294857025) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5899956226348877) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3315280079841614) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733350411057472) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (averageDuration_2 <= -0.5526518821716309) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6188385486602783) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9372610449790955) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3551086783409119) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462574541568756) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4592961519956589) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4602969884872437) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3955857753753662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3573181629180908) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0975580215454102) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4085301160812378) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.622090995311737) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5989364683628082) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616140723228455) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8356302082538605) { + if (averageDuration_2 <= -0.5864101052284241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2434280663728714) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5193299949169159) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0226791501045227) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.227587640285492) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5871792435646057) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3794839978218079) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (maxDuration_2 <= -0.4164966940879822) { + if (averageDuration_2 <= -0.522004246711731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7348887622356415) { + if (averageDuration_2 <= -0.29085399210453033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1882392168045044) { + if (maxDuration_2 <= -0.4919101446866989) { + if (maxDuration_2 <= -0.6114278733730316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.3475484102964401) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1466110944747925) { + if (maxDuration_2 <= -0.48160193860530853) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.930047035217285) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2156863808631897) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5434186458587646) { + if (averageDuration_2 <= -0.4295065701007843) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9016676545143127) { + if (maxDuration_2 <= -0.5218490064144135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4128761887550354) { + if (maxDuration_2 <= -0.41016484797000885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (maxDuration_2 <= -0.5455804169178009) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615143537521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2570513486862183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4624308943748474) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622198343276978) { + if (averageDuration_2 <= -0.5441543459892273) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6002825200557709) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153710365295) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.552420973777771) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5341393053531647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5100797116756439) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2967599183320999) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.051593413576483727) { + if (maxDuration_2 <= -0.37025733292102814) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4216177761554718) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (averageDuration_2 <= -0.47647401690483093) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5416989922523499) { + if (maxDuration_2 <= -0.5392942726612091) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.433924913406372) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (averageDuration_2 <= -0.4598925709724426) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5378756523132324) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5334436297416687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5778396427631378) { + if (maxDuration_2 <= -0.3563908040523529) { + if (averageDuration_2 <= -0.34592151641845703) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.390508696436882) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1409327387809753) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5355481207370758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0528243780136108) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6451756954193115) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.18894339352846146) { + if (averageDuration_2 <= -0.4743240475654602) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.23541931807994843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.7656015157699585) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.1672235205769539) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9485477209091187) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.0406333208084106) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.453783392906189) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.0718897394835949) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.46704642474651337) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.30141371488571167) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.918459951877594) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5016650259494781) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9961796998977661) { + if (maxDuration_2 <= -0.23827877640724182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.873420536518097) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4400789737701416) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7907251119613647) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + if (averageDuration_2 <= -0.31825171411037445) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2143862396478653) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281268656253815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4648159742355347) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5851300358772278) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6565110385417938) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6159905195236206) { + if (maxDuration_2 <= -0.2737060785293579) { + if (averageDuration_2 <= -0.22259613126516342) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7624515891075134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4572146087884903) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4819324612617493) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1378546357154846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2948054373264313) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.776781141757965) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.5896854400634766) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.772175431251526) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7087369561195374) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4781585931777954) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2512208893895149) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.278653383255005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.817312240600586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1646924018859863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.21278975158929825) { + if (averageDuration_2 <= -0.3192234933376312) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16025777161121368) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0459309816360474) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.552420973777771) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2557954639196396) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4371999502182007) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5884540677070618) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.5129289031028748) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8044033050537109) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7540424168109894) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.299040973186493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5158420503139496) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.270844578742981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7583757638931274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6220788955688477) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.479575276374817) { + if (maxDuration_2 <= -0.2639526128768921) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332667827606201) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.956267774105072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20334765315055847) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4353957921266556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9703625440597534) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3796340823173523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341555535793304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48324301838874817) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.18884215503931046) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0929139852523804) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.21744229644536972) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618036150932312) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5401434898376465) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5708314180374146) { + if (averageDuration_2 <= -0.30747516453266144) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5343220233917236) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.036251459270715714) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.938469648361206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5537965297698975) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29970555007457733) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21144329756498337) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1074102520942688) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08888150006532669) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.02009203191846609) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2904207110404968) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1908849012106657) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.155260801315308) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988297700882) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.783655047416687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0003146110102534294) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2610563039779663) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.42336505651474) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.425079345703125) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.44124336540699005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618817567825317) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.084824323654175) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1618068590760231) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6044227778911591) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0994303822517395) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4339929223060608) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2051321193575859) { + if (numDurations_2 <= 0.7239612340927124) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.253804087638855) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5954073369503021) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0179649889469147) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5189965069293976) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.207022488117218) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1508383750915527) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819309711456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.020112778060138226) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.19452083110809326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622540473937988) { + if (averageDuration_2 <= -0.10456223785877228) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (averageDuration_2 <= -0.4364365488290787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6214135885238647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.664660930633545) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (maxDuration_2 <= -0.30202920734882355) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23188431560993195) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.15736816078424454) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.27386142313480377) { + if (maxDuration_2 <= -0.2016003206372261) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6774446964263916) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.20290211588144302) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.656916618347168) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15490391850471497) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1978471651673317) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22014809399843216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4478986859321594) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03425528120715171) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2082081437110901) { + if (averageDuration_2 <= -0.6501690447330475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (averageDuration_2 <= -0.3586532920598984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3385978937149048) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7411036491394043) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1919825673103333) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 0.15480925142765045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.17117217928171158) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.41903918981552124) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.806822419166565) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5999326407909393) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4961591511964798) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.749491214752197) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.9084832668304443) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.039053201675415) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0769430994987488) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3936315774917603) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6924784481525421) { + if (averageDuration_2 <= -0.5233922898769379) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24241863191127777) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.4929831027984619) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3629505038261414) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.043676257133484) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22071382403373718) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15541428700089455) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6621103584766388) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627880573273) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014200667850673199) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14385507255792618) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9070866107940674) { + if (averageDuration_2 <= -0.5508539974689484) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.18452221155166626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + if (averageDuration_2 <= -0.6990936994552612) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.18992957472801208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.612455278635025) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2503615617752075) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283403396606) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5116496682167053) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40309110283851624) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2047903537750244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3894266039133072) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.588131844997406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9123512208461761) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.33969521522522) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18692556023597717) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.779147744178772) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.662408858537674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4443460702896118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.540958046913147) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.44751420617103577) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948375284671783) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0244272351264954) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= -0.4708472192287445) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4625998735427856) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607952237129211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06234296225011349) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.210874319076538) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07546784356236458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (averageDuration_2 <= -0.5421642959117889) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.970554769039154) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (averageDuration_2 <= -0.6110625863075256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4393004179000854) { + if (maxDuration_2 <= -0.04860787279903889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461968719959259) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.05959477461874485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3946945071220398) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1473565101623535) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.038375627249479294) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614478945732117) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.235006034374237) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13450168073177338) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + if (averageDuration_2 <= -0.5096052289009094) { + if (maxDuration_2 <= -0.05360988527536392) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617840647697449) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1634882539510727) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.435526967048645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2505820319056511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.147408366203308) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.42821289598941803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05540861934423447) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (averageDuration_2 <= -0.2046155408024788) { + if (numDurations_2 <= -0.9834946841001511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06105615384876728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49558527767658234) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9102784395217896) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2561350241303444) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.17996849864721298) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0696946233510971) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0044367047958076) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.17812837660312653) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.018788951449096203) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.22289925068616867) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3416653722524643) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2688431888818741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17916389554738998) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09785144776105881) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6598781645298004) { + if (maxDuration_2 <= -0.0851825661957264) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.20268184691667557) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.11857046186923981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0064657945185899734) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.1221967302262783) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33134444057941437) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3699389696121216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6446018517017365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.15442707389593124) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206601381302) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1394532173871994) { + if (maxDuration_2 <= -0.10878480970859528) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (averageDuration_2 <= -0.27785876393318176) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { + if (numDurations_2 <= 2.4314171075820923) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09330239146947861) { + if (maxDuration_2 <= -0.13671272993087769) { + if (maxDuration_2 <= -0.19156313687562943) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07322755828499794) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.794999748468399) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0311720967292786) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337137460708618) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (maxDuration_2 <= -0.12936021387577057) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1151999868452549) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158463835716) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9293405413627625) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18430721014738083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22068984806537628) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9554441869258881) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660343885422) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2045757919549942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9596757888793945) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618280529975891) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.1706356182694435) { + if (averageDuration_2 <= -0.2210707738995552) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02921954169869423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45621731877326965) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2509564235806465) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.053344935178756714) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.2184414863586426) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.1741737201809883) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.21549149602651596) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.18309377878904343) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (maxDuration_2 <= -0.04318040609359741) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11910314485430717) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.033245230093598366) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2758517563343048) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.728360652923584) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.460382878780365) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (maxDuration_2 <= -0.09987467154860497) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2735671252012253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619032740592957) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5351896584033966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12526218220591545) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.039100171998143196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1507693976163864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12330761551856995) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6102865934371948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1994336247444153) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0243672132492065) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06416112743318081) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.3693881034851074) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.322673797607422) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (averageDuration_2 <= -0.11060895398259163) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { + if (maxDuration_2 <= -0.04581689462065697) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7598154544830322) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.300660490989685) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.19578275829553604) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4357921481132507) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5138912498950958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.33937326073646545) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2702780961990356) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48421627283096313) { + if (averageDuration_2 <= -0.14667648822069168) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.266273260116577) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.702393352985382) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2403922602534294) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01612796261906624) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4440556168556213) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6462755799293518) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27955952286720276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.324747085571289) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.16055136919021606) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5688589513301849) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8376701474189758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2353584170341492) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1538746356964111) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27607475221157074) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8274345993995667) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9410592317581177) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5212291181087494) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (maxDuration_2 <= -0.14984982460737228) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4787360429763794) { + if (averageDuration_2 <= -0.2949259430170059) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.004849503166042268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.5079383850097656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.15910989791154861) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504844069480896) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8457118272781372) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1977542638778687) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5372855067253113) { + if (maxDuration_2 <= -0.1965552121400833) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4368640184402466) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (maxDuration_2 <= -0.18683473765850067) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3425183594226837) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.193001851439476) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.619449108839035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.45273467898368835) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.26229962706565857) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.07161573693156242) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.11622961238026619) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1029167175292969) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04465924948453903) { + if (averageDuration_2 <= -0.2471022829413414) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2178308367729187) { + if (averageDuration_2 <= -0.12506618350744247) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132515907288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08804169669747353) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3141508251428604) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13318386673927307) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4670807719230652) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5255667567253113) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.009483803994953632) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.17262369394302368) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.2566463351249695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9358725249767303) { + if (averageDuration_2 <= 0.020998301450163126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.608759045600891) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.444513738155365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15842972695827484) { + if (averageDuration_2 <= -0.410697340965271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.218268733471632) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5689411759376526) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34296341240406036) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7494911849498749) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (numDurations_2 <= -0.4143427312374115) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.067669153213501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.706470251083374) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.016964852809906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4464487433433533) { + if (averageDuration_2 <= -0.10593142360448837) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.03388035669922829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.2858690619468689) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.13485624641180038) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1672489643096924) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6651921272277832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 1.2931131720542908) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06535936146974564) { + if (maxDuration_2 <= -0.16747980564832687) { + if (averageDuration_2 <= -0.2794599086046219) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22159111499786377) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.16885486990213394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0543877482414246) { + if (maxDuration_2 <= -0.1991056501865387) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.29332125186920166) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6362839341163635) { + if (averageDuration_2 <= -0.16354993730783463) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0745406746864319) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.10308492183685303) { + if (maxDuration_2 <= -0.12798507511615753) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4472690224647522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6539501249790192) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.3693881034851074) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6404491662979126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.26639652252197266) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6262789368629456) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8605195879936218) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.970554769039154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8689790964126587) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0984068512916565) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3638110160827637) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1116220355033875) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5784355998039246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3220828175544739) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618543982505798) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (averageDuration_2 <= 0.013600532314740121) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4483657479286194) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.1572839766740799) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.979005753993988) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.942109614610672) { + if (averageDuration_2 <= -0.22711119800806046) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (averageDuration_2 <= 0.06667913729324937) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2684716433286667) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04431183263659477) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (maxDuration_2 <= -0.08158867433667183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4546797275543213) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5424005389213562) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6826821863651276) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.1426982283592224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.1676570400595665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.286486804485321) { + if (maxDuration_2 <= -0.11327513679862022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1401420310139656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701517701148987) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5186909139156342) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5394555926322937) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.091856598854065) { + if (maxDuration_2 <= -0.1547556295990944) { + if (averageDuration_2 <= -0.23951540887355804) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2203974947333336) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6790664792060852) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.023918727412819862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6171450018882751) { + if (maxDuration_2 <= -0.16755080223083496) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15753469616174698) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2561320783570409) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17720988392829895) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0050434538861736655) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2202489823102951) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.7791004180908203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0965296626091003) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03288457542657852) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (maxDuration_2 <= -0.07590781524777412) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06491485424339771) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.046052319929003716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319651782512665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.01946221012622118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5225109457969666) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.024487389251589775) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.452807605266571) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.726328134536743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.026483568362891674) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.45812590420246124) { + if (maxDuration_2 <= -0.13989119976758957) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.09470810368657112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.1425129994750023) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.728938341140747) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7261990308761597) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5251364707946777) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4869908541440964) { + if (maxDuration_2 <= -0.10350657999515533) { + if (averageDuration_2 <= -0.11741504818201065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20367415249347687) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461692214012146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.13433124125003815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6979585886001587) { + if (averageDuration_2 <= -0.10399672016501427) { + if (averageDuration_2 <= -0.10675084218382835) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33103421330451965) { + if (averageDuration_2 <= -0.24421410262584686) { + if (maxDuration_2 <= -0.13074064254760742) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.04020356200635433) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.606417253613472) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { + if (averageDuration_2 <= -0.13143712282180786) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.1832028329372406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.371296465396881) { + if (averageDuration_2 <= -0.4605397582054138) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + if (maxDuration_2 <= -0.44269220530986786) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9203162789344788) { + if (numDurations_2 <= 1.5776891708374023) { + if (averageDuration_2 <= -0.6517173647880554) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5152103006839752) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058825016022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4014349430799484) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5387052446603775) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4985998421907425) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.549740791320801) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5811039209365845) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3183590173721313) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6601145267486572) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (averageDuration_2 <= -0.5148124992847443) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2152851819992065) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9333924055099487) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.12116014957428) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.910454034805298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5454479157924652) { + if (maxDuration_2 <= -0.7194193303585052) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.46201013028621674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4643564224243164) { + if (averageDuration_2 <= -0.7157584726810455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4639714360237122) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.170398235321045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9174076318740845) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8302929401397705) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.407958030700684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0442404747009277) { + if (averageDuration_2 <= -0.5535960495471954) { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.143476486206055) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.83650541305542) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2380990982055664) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435039520264) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5729290843009949) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5342059135437012) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2569116353988647) { + if (maxDuration_2 <= -0.3581080287694931) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3613630533218384) { + if (averageDuration_2 <= -0.6947090327739716) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3365737274289131) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.815155506134033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2325400114059448) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1267486810684204) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.399016797542572) { + if (maxDuration_2 <= -0.10531997680664062) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.235919117927551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9742395877838135) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7511109113693237) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.090091347694397) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.56823468208313) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.09443336725235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.8910906314849854) { + if (maxDuration_2 <= -0.3255122900009155) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.6672534942626953) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1220508217811584) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4958640784025192) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3180382549762726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (maxDuration_2 <= -0.6840453147888184) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7416684925556183) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5697202682495117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5325501263141632) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08606896921992302) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2556352764368057) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233769893646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.518887460231781) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392571926117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6982201635837555) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.53657865524292) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.051715970039368) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781625390052795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5142332315444946) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838542461395) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.081448554992676) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3796340823173523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233769893646) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.42197048664093) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6517821550369263) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7699747681617737) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.20130643993616104) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32874099910259247) { + if (maxDuration_2 <= -0.5445268452167511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.492292881011963) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.416452884674072) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7556182742118835) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1833787560462952) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.6263859272003174) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.92511522769928) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6666365265846252) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + if (averageDuration_2 <= -0.6731269657611847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.6988641023635864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6708867847919464) { + if (averageDuration_2 <= -0.6948378682136536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.7274783849716187) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0611408948898315) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7543061971664429) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4736960232257843) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0026832818984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.200182020664215) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349805697799) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953777194023132) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9526275098323822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.077729225158691) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6850890815258026) { + if (maxDuration_2 <= -0.7283901274204254) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17708710581064224) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15564509481191635) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.151379346847534) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3863663822412491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5888849198818207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + if (averageDuration_2 <= -0.5159313976764679) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4292654991149902) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3442365527153015) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.7154715061187744) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9585451483726501) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5226146280765533) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (averageDuration_2 <= -0.6840804517269135) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5678756535053253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3066815733909607) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.0718897394835949) { + if (averageDuration_2 <= -0.6736148595809937) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8128155767917633) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3302619457244873) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6578723192214966) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6071547269821167) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2110661268234253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7555900812149048) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1384708285331726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7253622710704803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5954254865646362) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.419930636882782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5992175340652466) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8498036861419678) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.1043844074010849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.04252827167511) { + if (averageDuration_2 <= -0.5646933019161224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1247397661209106) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.007515541277825832) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.011162791401147842) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5301892459392548) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7070369124412537) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.193760514259338) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21798385679721832) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3783380091190338) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093146696686745) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1158908903598785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2606525421142578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8772926330566406) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4768738746643066) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (maxDuration_2 <= -0.45229367911815643) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (averageDuration_2 <= -0.7164859175682068) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2880917489528656) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8938599228858948) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31303733587265015) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.773085743188858) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8479446172714233) { + if (averageDuration_2 <= -0.5629481375217438) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.9985268115997314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5163151621818542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.6624360680580139) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.315594434738159) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.069137811660767) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.91882586479187) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1493337154388428) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5964350700378418) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7126517593860626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036517620087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.526206016540527) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.730664491653442) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.100101709365845) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.55797278881073) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.04611337184906) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.332209289073944) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.447756290435791) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9135369062423706) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.084824323654175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6950976550579071) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5387052446603775) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6144105195999146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898410797119) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.308491945266724) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.19341379404068) { + if (maxDuration_2 <= -0.6772676706314087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6744437217712402) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4846593141555786) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0900914072990417) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.159201204776764) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.2315618991851807) { + if (averageDuration_2 <= -0.592371016740799) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.484916925430298) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.002244919538498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1646387577056885) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0132548809051514) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9981546401977539) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6419752240180969) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3260877653956413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -6.3989098072052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { + if (maxDuration_2 <= -0.6203606724739075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3452826142311096) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.057259261608124) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721573352814) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.5784499645233154) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -5.964418172836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.549441695213318) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.454709768295288) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4105457067489624) { + if (averageDuration_2 <= -0.30036094784736633) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627582550049) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.3138919323682785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.281707301735878) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.002405945211648941) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3876566141843796) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.0042311549186707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.70000422000885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8482733368873596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.18438546359539032) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.21996235102415085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.721589595079422) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.16545112431049347) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9485477805137634) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.165159225463867) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.012774040456861258) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.092849254608154) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + if (maxDuration_2 <= -0.12673895433545113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0903413891792297) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3176172971725464) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.735241025686264) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27142536640167236) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { + if (maxDuration_2 <= -0.18253431469202042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.015712805092334747) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48409511148929596) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.56138277053833) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + if (averageDuration_2 <= 0.03280335571616888) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.631614089012146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { + if (averageDuration_2 <= -0.2845531553030014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49292998015880585) { + if (averageDuration_2 <= -0.31117549538612366) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.011063045356422663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1881467029452324) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4824860244989395) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4575536549091339) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5354723632335663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.3064555525779724) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30675648152828217) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718024134635925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.43490731716156) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21951200813055038) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.15587187558412552) { + if (maxDuration_2 <= -0.205163836479187) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0972643792629242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368339061737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.128074884414673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36861181259155273) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.772175431251526) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.07179300859570503) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40125027298927307) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (maxDuration_2 <= -0.31105560064315796) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014949262142181) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.2166862040758133) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.102656841278076) { + if (averageDuration_2 <= -0.40940138697624207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.8564924001693726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7289382815361023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7752944231033325) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.142114996910095) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5503549575805664) { + if (maxDuration_2 <= -0.43792326748371124) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5470973551273346) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.326260566711426) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.44955162703990936) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9792207479476929) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.34638895094394684) { + if (maxDuration_2 <= -0.2779937833547592) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0917135737836361) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6401693522930145) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22546830773353577) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8071976900100708) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8755281567573547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.771754503250122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2710198760032654) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5110293626785278) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.30548790097236633) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.14300143718719482) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.120387554168701) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1238964796066284) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03948767390102148) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1434461697936058) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { + if (maxDuration_2 <= -0.28900593519210815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.1865309774875641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.454709768295288) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3092341423034668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.29295703768730164) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.981550097465515) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4064040184020996) { + if (averageDuration_2 <= -0.38568927347660065) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4030160754919052) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6033900082111359) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4412788599729538) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6451467275619507) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 0.7239612340927124) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5055821239948273) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.02385823894292116) { + if (maxDuration_2 <= -0.5010809302330017) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1475950479507446) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3226674795150757) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.2662731409072876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2304881811141968) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6220910549163818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8605195879936218) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9523173570632935) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5311709344387054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0529807209968567) { + if (maxDuration_2 <= -0.45073102414608) { + if (averageDuration_2 <= -0.3758976310491562) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998293876648) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.415175676345825) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7469977140426636) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025970578193665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5545837879180908) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165159225464) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9601624608039856) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.431552529335022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.2521325498819351) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.5927202701568604) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1646878719329834) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8188689947128296) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2449105903506279) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2541909217834473) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.059758722782135) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { + if (averageDuration_2 <= -0.4046422392129898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5964350700378418) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6338953971862793) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7900195121765137) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.17592425644397736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.21280329674482346) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3410741090774536) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7740775346755981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 5.846328973770142) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.35295209288597107) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9587630033493042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8430447578430176) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4978281259536743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.664973020553589) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.4340795278549194) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.407717943191528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5098878145217896) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5364645272493362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.435187578201294) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (maxDuration_2 <= -0.03313572145998478) { + if (averageDuration_2 <= -0.4365865886211395) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0224738121032715) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8331891894340515) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2084840536117554) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5795921385288239) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.7510048151016235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.19696440547704697) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3217923939228058) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2660680264234543) { + if (maxDuration_2 <= -0.16755583882331848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7206164300441742) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.021750450134277) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3639936447143555) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.938991367816925) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236781001091003) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.016964852809906) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.5558815002441406) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { + if (maxDuration_2 <= -0.4751918315887451) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.451817810535431) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.537806510925293) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.3491384983062744) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.4990852028131485) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.0042311549186707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.41827137768268585) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.5911834239959717) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.9434726238250732) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4114603996276855) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.716659069061279) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.1149210929870605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.486834526062012) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1209300756454468) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.6307660341262817) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8949843645095825) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.273658275604248) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2674176692962646) { + if (averageDuration_2 <= -0.6852892637252808) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.09687595441937447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.546828269958496) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.37771689891815186) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (maxDuration_2 <= -0.7618089616298676) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.257839322090149) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184718966484) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1456851959228516) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609603881835938) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.445444941520691) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4729609787464142) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6206668957784132) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.702006757259369) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4923457056283951) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.078429937362671) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5900544226169586) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.703396797180176) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812396168708801) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.859567403793335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5968583822250366) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8211257457733154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8173737525939941) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.16935396194458) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4263787269592285) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613677859306335) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.3693881034851074) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5400769114494324) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6010546684265137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.08607661351561546) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2222009897232056) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.9104539155960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + if (averageDuration_2 <= -0.7136699855327606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { + if (averageDuration_2 <= -0.2793477922677994) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.9084832668304443) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6948850154876709) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5824715495109558) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5392308235168457) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.09964840486645699) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0243672728538513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610952138900757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0674948692321777) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.411447286605835) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612740278244019) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.28065918385982513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.077553749084473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.802748203277588) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.9713491201400757) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.27393679320812225) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.656718969345093) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.3124085664749146) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.089825987815857) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6608555614948273) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.280956506729126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.552486181259155) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6939990222454071) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.334265947341919) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.7878230810165405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.215251207351685) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.381303310394287) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (maxDuration_2 <= -0.39912496507167816) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.251320123672485) { + if (averageDuration_2 <= -0.49606817960739136) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614977836608887) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.959371268749237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.474029779434204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.11270809173584) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.233586072921753) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1466110944747925) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753037750720978) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6529807150363922) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.36843787133693695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0804295539855957) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.34107664227485657) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03974040225148201) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.235338807106018) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615808129310608) { + if (maxDuration_2 <= -0.6111871302127838) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9910715818405151) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3926750421524048) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4003682136535645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617410898208618) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4562341868877411) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 6.366624116897583) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3226674795150757) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.304189920425415) { + if (averageDuration_2 <= -0.5895276665687561) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.1703981161117554) { + if (averageDuration_2 <= -0.6324915885925293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6017815172672272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1733288764953613) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.972083568572998) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.121818780899048) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.240534543991089) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.348293781280518) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.582572817802429) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.289841890335083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.3387858867645264) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5688201189041138) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.647507429122925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1154991388320923) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.0093899965286255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7367648184299469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.805253267288208) { + if (maxDuration_2 <= -0.43624162673950195) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.15319287776947) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4251141548156738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.192003607749939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.0188469886779785) { + if (averageDuration_2 <= -0.5105845332145691) { + if (averageDuration_2 <= -0.5142288208007812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0730392932891846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0757912397384644) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0890586376190186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.486926555633545) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.336419701576233) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04193134419620037) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4297670722007751) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.027143120765686) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.3659674823284149) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.451099693775177) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.07488466426730156) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1578196287155151) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.405145883560181) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5362565517425537) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1392745077610016) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.277600035071373) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14361479878425598) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44641438126564026) { + if (averageDuration_2 <= -0.6040846407413483) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984920978546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36672458052635193) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.237127423286438) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.359202042222023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4467395842075348) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484863996505737) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5507397055625916) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26305386424064636) { + if (averageDuration_2 <= -0.1997433751821518) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3049436956644058) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (maxDuration_2 <= -0.3425394892692566) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.34588588774204254) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34553655982017517) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11485902220010757) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40020838379859924) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5649442076683044) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (averageDuration_2 <= -0.2789972871541977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6848884522914886) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3239813446998596) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06743620336055756) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.2310083657503128) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6346502304077148) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.2902824878692627) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (maxDuration_2 <= -0.3351137191057205) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19573838263750076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28740212321281433) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5079361349344254) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.26567794382572174) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44986334443092346) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5298140048980713) { + if (maxDuration_2 <= -0.4574047029018402) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5197491645812988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3605836182832718) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (maxDuration_2 <= -0.27532942593097687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643943786621) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326768159866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2920520603656769) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (maxDuration_2 <= -0.13024671375751495) { + if (averageDuration_2 <= -0.32367953658103943) { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.41343969106674194) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5598048865795135) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4035778045654297) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.022884486243128777) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 0.15480925142765045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6143312454223633) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4466603696346283) { + if (averageDuration_2 <= -0.5115528404712677) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.288336455821991) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.33150455355644226) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2501402571797371) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.25492869317531586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (averageDuration_2 <= -0.5224162340164185) { + if (maxDuration_2 <= -0.4338708519935608) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8247130513191223) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.399388924241066) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976390838623047) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0889461040496826) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5746717751026154) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5760852098464966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.7187942266464233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7374191284179688) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.5562760233879089) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04803532920777798) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41536471247673035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5071395933628082) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6510039567947388) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1250063180923462) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15363410115242004) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3508547991514206) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.22302676737308502) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.092854619026184) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26850663125514984) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.626916289329529) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (averageDuration_2 <= -0.38058747351169586) { + if (maxDuration_2 <= -0.5392992794513702) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (maxDuration_2 <= -0.15295980870723724) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7629000246524811) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6383083462715149) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (maxDuration_2 <= -0.21893391013145447) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620410799980164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26024943590164185) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (averageDuration_2 <= -0.05697101540863514) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485337555408478) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27534346282482147) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3038221597671509) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.300806924700737) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.17293252050876617) { + if (maxDuration_2 <= -0.2942740172147751) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4123512953519821) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.15119710564613342) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33534999191761017) { + if (averageDuration_2 <= -0.2509738355875015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613766074180603) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.24105703085660934) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6421031355857849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4202617257833481) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.2922681123018265) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5026886910200119) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251758337021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.29633864760398865) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (averageDuration_2 <= -0.06885091215372086) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2608128637075424) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.05748083256185055) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.2335527539253235) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2094939425587654) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5184737741947174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (maxDuration_2 <= -0.24190295487642288) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.060835327953100204) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.03012752439826727) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8540283441543579) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3624744117259979) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1686182022094727) { + if (maxDuration_2 <= -0.3594832420349121) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06849193200469017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3446215093135834) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486036121845245) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.22750668972730637) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618065357208252) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3731321543455124) { + if (maxDuration_2 <= -0.4179935157299042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.18186046183109283) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5457851588726044) { + if (averageDuration_2 <= -0.3267345726490021) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15378113090991974) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19119910150766373) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12234972789883614) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45772960782051086) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.12936146557331085) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1380874589085579) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (averageDuration_2 <= 0.09028109908103943) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.01222249073907733) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.08697061613202095) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.06711684539914131) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (maxDuration_2 <= -0.03058780450373888) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4629340767860413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6809765100479126) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11156419664621353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43737851083278656) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27643708884716034) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (averageDuration_2 <= -0.03691084869205952) { + if (maxDuration_2 <= -0.07142750918865204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.4114472270011902) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.170151710510254) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (maxDuration_2 <= -0.06224141828715801) { + if (averageDuration_2 <= -0.04430600255727768) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28466878831386566) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.031003235839307308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.1463925912976265) { + if (averageDuration_2 <= -0.27392497658729553) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.350170373916626) { + if (averageDuration_2 <= -0.39635835587978363) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6690318286418915) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5896690785884857) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29930347204208374) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (averageDuration_2 <= -0.6216040551662445) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35607700049877167) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25773589313030243) { + if (averageDuration_2 <= -0.6397430002689362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05284426733851433) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (averageDuration_2 <= -0.6133953630924225) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536155462265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.4532563239336014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23341833800077438) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32813143730163574) { + if (maxDuration_2 <= -0.4856392592191696) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.130440017208457) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.27907538414001465) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.181272566318512) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5358547270298004) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2025156244635582) { + if (averageDuration_2 <= -0.6169167459011078) { + if (maxDuration_2 <= -0.5921514928340912) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.44399408996105194) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5839044451713562) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.982878804206848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.558965653181076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.48913243412971497) { + if (maxDuration_2 <= -0.4559232145547867) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33375950157642365) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5292666554450989) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13445447385311127) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36075545847415924) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4048230648040771) { + if (maxDuration_2 <= -0.46547138690948486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2319604605436325) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6050042808055878) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7284772992134094) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485196888446808) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6535642147064209) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612398147583008) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4057985544204712) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.46311376988887787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03723842836916447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6164225041866302) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5786024034023285) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3218132108449936) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.276781290769577) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30795322358608246) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14219794422388077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.2278490737080574) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19381573051214218) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.06622279807925224) { + if (averageDuration_2 <= 0.2189711108803749) { + if (averageDuration_2 <= -0.026429740712046623) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2563336193561554) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3646692931652069) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486138939857483) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32861311733722687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.10053576901555061) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09869623556733131) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21961239725351334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5880689024925232) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09018248692154884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.14417143911123276) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4086911827325821) { + if (averageDuration_2 <= -0.4813312441110611) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609525203704834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21144767105579376) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23500120639801025) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2153882384300232) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.342326283454895) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4657622128725052) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5062268972396851) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5952821969985962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.595462292432785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964074045419693) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6761052310466766) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16504602879285812) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (averageDuration_2 <= -0.18546003848314285) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454745411873) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485066950321198) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485416233539581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.44629061222076416) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613297581672668) { + if (maxDuration_2 <= -0.43443578481674194) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.2868582606315613) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5971544981002808) { + if (maxDuration_2 <= -0.17822104692459106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.42309097945690155) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11867078393697739) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14972440898418427) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5740453004837036) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.18494271486997604) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.546473354101181) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1169698238372803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46102549135684967) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5677633583545685) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.28862954676151276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4645984172821045) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1986772045493126) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.217516228556633) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2437117099761963) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3111402243375778) { + if (maxDuration_2 <= -0.49808740615844727) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5546018779277802) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09712500497698784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485787272453308) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (averageDuration_2 <= -0.27443087100982666) { + if (maxDuration_2 <= -0.3913673758506775) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4503106027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3021524250507355) { + if (averageDuration_2 <= -0.40916503965854645) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -0.9834946841001511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6431629955768585) { + if (averageDuration_2 <= -0.21236743032932281) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (averageDuration_2 <= -0.1248534768819809) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5805456340312958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22568033635616302) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.23806851357221603) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.3782074600458145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.026337006129324436) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27217674255371094) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (maxDuration_2 <= -0.2052270621061325) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21287938952445984) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5354227125644684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4280156046152115) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.025454211980104446) { + if (averageDuration_2 <= -0.6227698624134064) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2506163492798805) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485627233982086) { + if (maxDuration_2 <= -0.3786582052707672) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= -0.5407049357891083) { + if (averageDuration_2 <= -0.5425100028514862) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.47841085493564606) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6033284664154053) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (maxDuration_2 <= -0.3092244118452072) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1354902684688568) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.49435923993587494) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13199259340763092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (averageDuration_2 <= -0.4062149226665497) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0243672132492065) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.27780647575855255) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3298847675323486) { + if (averageDuration_2 <= -0.5741041898727417) { + if (maxDuration_2 <= -0.5356573462486267) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17572815716266632) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3065217733383179) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (averageDuration_2 <= -0.7066989839076996) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5495784282684326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.025656044483184814) { + if (averageDuration_2 <= -0.053291065618395805) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3013905733823776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13223453983664513) { + if (averageDuration_2 <= -0.021355340257287025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.20365672558546066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11071574315428734) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616687893867493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485424280166626) { + if (maxDuration_2 <= -0.35018572211265564) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4453241229057312) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0336318789049983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2726322412490845) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05464697815477848) { + if (maxDuration_2 <= -0.4395771324634552) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26393668353557587) { + if (maxDuration_2 <= -0.290806844830513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2822015732526779) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6225183606147766) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6893267929553986) { + if (averageDuration_2 <= -0.16600551456212997) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617733359336853) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (maxDuration_2 <= -0.18823019415140152) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.19589168578386307) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (averageDuration_2 <= -0.2400091215968132) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.2258623242378235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10516176000237465) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.36535976827144623) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484157085418701) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.446844458580017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (averageDuration_2 <= -0.5901563763618469) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26641348004341125) { + if (maxDuration_2 <= -0.4465293288230896) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03450704365968704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03806346654891968) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5838076174259186) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3047941029071808) { + if (maxDuration_2 <= -0.30740611255168915) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7431910932064056) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.11029172502458096) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.1004982627928257) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.48742975294589996) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616023302078247) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606166541576) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611656069755554) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.12076423317193985) { + if (maxDuration_2 <= -0.2923644632101059) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.8303110599517822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.014578585978597403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.41785159707069397) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (maxDuration_2 <= -0.6130513846874237) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398807287216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6085431575775146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.42576293647289276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.1941896453499794) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16942478716373444) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5920597612857819) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617918729782104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.24272609502077103) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4498812556266785) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.5418986082077026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7708433568477631) { + if (averageDuration_2 <= -0.3478282243013382) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.23312640190124512) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23145928233861923) { + if (averageDuration_2 <= -0.16028878837823868) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2745980769395828) { + if (maxDuration_2 <= -0.033908216282725334) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5914424359798431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16737931221723557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3343760669231415) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4087417274713516) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.09322386980056763) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.0011627247731667012) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (maxDuration_2 <= -0.10821232944726944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.707603245973587) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.10416875779628754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.11399137228727341) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39911821484565735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.09541979804635048) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.1866975501179695) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43961067497730255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614039659500122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.15497000515460968) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1717139557003975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3012038618326187) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.031132339499890804) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612632393836975) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.19475939869880676) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26718054711818695) { + if (averageDuration_2 <= -0.48565714061260223) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4939206540584564) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.037075139582157135) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3324902802705765) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5342159569263458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.361087366938591) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26585550606250763) { + if (averageDuration_2 <= -0.33556507527828217) { + if (averageDuration_2 <= -0.43192683160305023) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (averageDuration_2 <= -0.3647909164428711) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3494781106710434) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748583048582077) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3439832329750061) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7468894422054291) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46466776728630066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4107353240251541) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (averageDuration_2 <= -0.1585393249988556) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485209107398987) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5340007245540619) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4769394248723984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3260144591331482) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461271047592163) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615974426269531) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5098969042301178) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6485679149627686) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20011595636606216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1891184002161026) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6448647081851959) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6138264834880829) { + if (averageDuration_2 <= -0.23387668281793594) { + if (maxDuration_2 <= -0.39490559697151184) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (maxDuration_2 <= -0.4254269152879715) { + if (averageDuration_2 <= -0.3160969465970993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.70689257979393) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.313244104385376) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0048859119415283) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5401894152164459) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3328492641448975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5573665201663971) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3073357343673706) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3692297041416168) { + if (averageDuration_2 <= -0.39892035722732544) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5975027680397034) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6492940485477448) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.386329784989357) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15189256519079208) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080834388733) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48656901717185974) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15483064204454422) { + if (averageDuration_2 <= -0.31090596318244934) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3310801535844803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30606357753276825) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.46891026198863983) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4919792115688324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35769978165626526) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41259224712848663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.35252854228019714) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (maxDuration_2 <= -0.4991917163133621) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461735188961029) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5864637792110443) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + if (maxDuration_2 <= -0.23609291017055511) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.21620120853185654) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4272029399871826) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7479060888290405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7602596282958984) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (averageDuration_2 <= -0.3254978358745575) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5168293416500092) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12670142203569412) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5703205764293671) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5287594795227051) { + if (averageDuration_2 <= -0.37135712802410126) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0805509015917778) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.57000932097435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4221958518028259) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.020724645350128412) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21614987403154373) { + if (maxDuration_2 <= -0.48240742087364197) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43773965537548065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5399881303310394) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485050559043884) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (averageDuration_2 <= -0.34997664391994476) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332325994968414) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5385791659355164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.40933309495449066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.1954646185040474) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7365859746932983) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619598984718323) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4374384135007858) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.25147758424282074) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615915417671204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.3406946361064911) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3722996264696121) { + if (maxDuration_2 <= -0.318879172205925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485743761062622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7447555661201477) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.27423177659511566) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4036545902490616) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.22167803347110748) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.24704985320568085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.43059241771698) { + if (maxDuration_2 <= -0.39243610203266144) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4684813618659973) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24007270485162735) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0529265608638525) { + if (averageDuration_2 <= -0.4789075255393982) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06270938011584803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.695807009935379) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461421549320221) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6009113788604736) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6571535468101501) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.009557085111737251) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (numDurations_2 <= -0.9834946841001511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07424503192305565) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6288356482982635) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1725463718175888) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.49582792818546295) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7155901193618774) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28862933814525604) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (averageDuration_2 <= -0.46872568130493164) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07167908176779747) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04285782016813755) { + if (averageDuration_2 <= -0.46103353798389435) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623077511787415) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2055632472038269) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22886675596237183) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988822154700756) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4250350594520569) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4498503506183624) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.584939181804657) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2669576555490494) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30125565826892853) { + if (averageDuration_2 <= -0.6300389766693115) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5051824152469635) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6538885235786438) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2452918365597725) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08364953845739365) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06604358926415443) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615065455436707) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18552514910697937) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.43779824674129486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.47833119332790375) { + if (averageDuration_2 <= -0.5713742077350616) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5152589678764343) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4163975715637207) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.45608825981616974) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5744371116161346) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485424280166626) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46545979380607605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485651671886444) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17166516184806824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.435471773147583) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.532338559627533) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5232116281986237) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32090237736701965) { + if (averageDuration_2 <= -0.24739494174718857) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (maxDuration_2 <= -0.363629087805748) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.41922347247600555) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22670163959264755) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.8750421404838562) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331952571869) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1837560385465622) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06582276150584221) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (averageDuration_2 <= -0.37779204547405243) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4408485144376755) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07599927112460136) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.35519783198833466) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20365030318498611) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5533127784729004) { + if (averageDuration_2 <= -0.3970071077346802) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23250308632850647) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (maxDuration_2 <= -0.37859490513801575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3282715678215027) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20586559176445007) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0790926031768322) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0731804370880127) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1176927238702774) { + if (averageDuration_2 <= -0.2579067796468735) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.39545752108097076) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2537977695465088) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.9304614961147308) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09303806722164154) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.4055502414703369) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.07717474922537804) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= -0.33939434587955475) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5418084263801575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.178146094083786) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.2084173560142517) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (maxDuration_2 <= -0.4661272317171097) { + if (averageDuration_2 <= -0.3737822026014328) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3327739089727402) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.347231850028038) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5545052289962769) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6963427662849426) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614967703819275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622482061386108) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.019909122958779335) { + if (averageDuration_2 <= -0.3836795538663864) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0268927812576294) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614030122756958) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8702580034732819) { + if (maxDuration_2 <= -0.37985122203826904) { + if (averageDuration_2 <= -0.3853563815355301) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.33158570528030396) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1191994547843933) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4371566772460938) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.554470419883728) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.7970774918794632) { + if (averageDuration_2 <= -0.34461481869220734) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.08547664806246758) { + if (averageDuration_2 <= -0.2943752259016037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (maxDuration_2 <= -0.3287896066904068) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.09727991744875908) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48045238852500916) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15083543211221695) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.19596700370311737) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6162827610969543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.013856448233127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.585039883852005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3231832683086395) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.448899269104004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.12713701650500298) { + if (maxDuration_2 <= -0.27950336039066315) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (maxDuration_2 <= -0.2518235743045807) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17754186689853668) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.10035017877817154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5684525072574615) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19312189519405365) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485952377319336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05984428524971008) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.429594099521637) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4500522017478943) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07842618972063065) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1106979064643383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.46954141557216644) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619374871253967) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.31687071919441223) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (maxDuration_2 <= -0.2285911962389946) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.008545245043933392) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.38869279623031616) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24204733967781067) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4651928246021271) { + if (averageDuration_2 <= -0.3771643340587616) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2997138798236847) { + if (averageDuration_2 <= -0.3675195276737213) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18549950420856476) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5444612205028534) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.009863323532044888) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (maxDuration_2 <= -0.33208952844142914) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0718638002872467) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.30602969229221344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5957303643226624) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454186618328) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3882166147232056) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.39599609375) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142840951681) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05622479319572449) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.10064147040247917) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5017101019620895) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3111286908388138) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486079931259155) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29417721927165985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.18212772905826569) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04889783263206482) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18738115578889847) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5427532494068146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5591905117034912) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2019961252808571) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5322945713996887) { + if (averageDuration_2 <= -0.36329546570777893) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341555535793304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (averageDuration_2 <= -0.1315813958644867) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.15519636124372482) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.19040828943252563) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.08886498957872391) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (averageDuration_2 <= -0.13396944105625153) { + if (averageDuration_2 <= -0.40161460638046265) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (maxDuration_2 <= -0.13448134809732437) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618749618530273) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17735284566879272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618397951126099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1888403594493866) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.28842975199222565) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11544476449489594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.32608775794506073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984622955322) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9542279541492462) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.0585829615592957) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4411871433258057) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.13334167748689651) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6009238660335541) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5486850738525391) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.6086798906326294) { + if (averageDuration_2 <= -0.19284972548484802) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.45875778794288635) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4634343385696411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4271758198738098) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.18252739310264587) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483670711517) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623731970787048) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17323505878448486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196251034736633) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31158509850502014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.1741941049695015) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.564587339758873) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8647972941398621) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.32303541898727417) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.04989788681268692) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7849974930286407) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485733032226562) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617557525634766) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04634569585323334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3742292821407318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (maxDuration_2 <= -0.13867558538913727) { + if (averageDuration_2 <= -0.09006946533918381) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11714250594377518) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.12964393943548203) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30231238901615143) { + if (averageDuration_2 <= -0.5025456547737122) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484799027442932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33816035091876984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5038608610630035) { + if (maxDuration_2 <= -0.4149087071418762) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (maxDuration_2 <= -0.44625823199748993) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485806047916412) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.41941168904304504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.13165994733572006) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.22072111070156097) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248238757252693) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24461984634399414) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2549711614847183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (averageDuration_2 <= -0.41125287115573883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964074045419693) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (averageDuration_2 <= -0.3392566740512848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.21270109713077545) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2620590478181839) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.1411929950118065) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03645376116037369) { + if (averageDuration_2 <= -0.3692460358142853) { + if (maxDuration_2 <= -0.4048158824443817) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0239300727844238) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21624477952718735) { + if (averageDuration_2 <= -0.5941737592220306) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.5134525299072266) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5709969699382782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21470312774181366) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14238231629133224) { + if (averageDuration_2 <= -0.371366411447525) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6067546904087067) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18146149814128876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (maxDuration_2 <= -0.290973961353302) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5059475600719452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.22102482616901398) { + if (maxDuration_2 <= -0.44921649992465973) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.33664846420288086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6912778913974762) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.17261873185634613) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.967400997877121) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.06424967106431723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.653190016746521) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5018784701824188) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461836814880371) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5431978404521942) { + if (averageDuration_2 <= -0.393062025308609) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03404129762202501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (averageDuration_2 <= -0.0007950448198243976) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618417024612427) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32562756538391113) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406876802444) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485960125923157) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13230181485414505) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5323525667190552) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09061892330646515) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.1820175126194954) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.059369206428528) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5605961978435516) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2812333106994629) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32915425300598145) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5607762932777405) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4283110201358795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251907348633) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.311371847987175) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.20424193143844604) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2342447191476822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2969321012496948) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.12996051460504532) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (averageDuration_2 <= -0.117515929043293) { + if (maxDuration_2 <= -0.1691742092370987) { + if (averageDuration_2 <= -0.3344445526599884) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0494094491004944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (maxDuration_2 <= -0.2986302971839905) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6229180097579956) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3281133621931076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3492284119129181) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.15628253668546677) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46148020029068) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.14508580416440964) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (averageDuration_2 <= -0.08140381053090096) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.054250599816441536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2447572872042656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.38797543942928314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06779986619949341) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6806835532188416) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2398415058851242) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.17757514119148254) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6313913464546204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.1767014041543007) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7304023802280426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.18839267641305923) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15805791318416595) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.134348064661026) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4936756044626236) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5386260449886322) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8144661486148834) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.210120789706707) { + if (averageDuration_2 <= -0.411627396941185) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23294053971767426) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4171983301639557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485838532447815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5011187791824341) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484790682792664) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.47022151947021484) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7442229390144348) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.22152316570281982) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (averageDuration_2 <= -0.43750278651714325) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.33040323853492737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2692529186606407) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2076359987258911) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10894132405519485) { + if (averageDuration_2 <= -0.7026169300079346) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07571825012564659) { + if (averageDuration_2 <= -0.2833278179168701) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32755759358406067) { + if (maxDuration_2 <= -0.49297134578227997) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.45725663006305695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5586313605308533) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4732368588447571) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5468974411487579) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (numDurations_2 <= 0.7239612340927124) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.635094553232193) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.580347329378128) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15345080941915512) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5737443566322327) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6117481291294098) { + if (averageDuration_2 <= -0.14872479438781738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4682319760322571) { + if (averageDuration_2 <= -0.6329787373542786) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5265552699565887) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6364681124687195) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24119549244642258) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5198698341846466) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9766682758927345) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28985482454299927) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6870878636837006) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (averageDuration_2 <= -0.2330113723874092) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + if (maxDuration_2 <= -0.2729361802339554) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481113374233246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5617681741714478) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.31682224571704865) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485749125480652) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.36459027230739594) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3748958557844162) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2510738670825958) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485651671886444) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3678411692380905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.033834950998425484) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461551547050476) { + if (averageDuration_2 <= -0.4351094514131546) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3786516338586807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.26239001750946045) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484677135944366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5395406186580658) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.25661545991897583) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5088426470756531) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.0933137871325016) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5421836376190186) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (maxDuration_2 <= -0.07538862153887749) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2396336793899536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.09175312519073486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (maxDuration_2 <= -0.06178549863398075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.18791374564170837) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3710092157125473) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22841762751340866) { + if (averageDuration_2 <= -0.30653025209903717) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35229504108428955) { + if (averageDuration_2 <= -0.4406532943248749) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7248112261295319) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3586006313562393) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326768159866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6012490391731262) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.49731501936912537) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4385754466056824) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5568554997444153) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484831213951111) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (averageDuration_2 <= -0.5757383704185486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.613898754119873) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.16823644191026688) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.528982400894165) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617508053779602) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.443659707903862) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { + if (maxDuration_2 <= -0.4903828948736191) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.24775946885347366) { + if (maxDuration_2 <= -0.3933224678039551) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5105916857719421) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483011782169342) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5256025493144989) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21374674141407013) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5628361999988556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3866190314292908) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3980271518230438) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3673776090145111) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5177305340766907) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21284977346658707) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22005673497915268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3866794854402542) { + if (maxDuration_2 <= -0.4711825102567673) { + if (averageDuration_2 <= -0.3895966708660126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (averageDuration_2 <= -0.19026585668325424) { + if (maxDuration_2 <= -0.5140534043312073) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4380033314228058) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { + if (averageDuration_2 <= -0.20907174795866013) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5337484776973724) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18107213824987411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5156789720058441) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621152877807617) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5445589125156403) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42021267116069794) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5840253233909607) { + if (maxDuration_2 <= -0.3280450105667114) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3253198564052582) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.41310399770736694) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.6604152023792267) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13672755658626556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32247303426265717) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3078061491250992) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29910269379615784) { + if (maxDuration_2 <= -0.5431819260120392) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5771022439002991) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7708979845046997) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3012620359659195) { + if (averageDuration_2 <= -0.5138199627399445) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3406316041946411) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (averageDuration_2 <= -0.6235829293727875) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5304751694202423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09578686952590942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.47485746443271637) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6056628525257111) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5389014780521393) { + if (averageDuration_2 <= -0.6948243081569672) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 6.415480613708496) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7376938760280609) { + if (maxDuration_2 <= -0.7041648030281067) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (averageDuration_2 <= -0.6029072403907776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4010132849216461) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616355299949646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21628227084875107) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5637966990470886) { + if (maxDuration_2 <= -0.49066653847694397) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.282077819108963) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9102553725242615) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619072079658508) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3457256257534027) { + if (numDurations_2 <= -0.6989187002182007) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30467693507671356) { + if (averageDuration_2 <= -0.24636389315128326) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42191745340824127) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (averageDuration_2 <= -0.3778180032968521) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.41422486305236816) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3155362457036972) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.38002657890319824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0805245153605938) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15032322704792023) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (maxDuration_2 <= -0.49999192357063293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13431144878268242) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24069173634052277) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02172175794839859) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31877896189689636) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4082011580467224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17324179410934448) { + if (averageDuration_2 <= -0.24214886128902435) { + if (averageDuration_2 <= -0.34338271617889404) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5845167636871338) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.005252549424767494) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486035823822021) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14058390259742737) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7355774939060211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1959613859653473) { + if (averageDuration_2 <= -0.2887658625841141) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748522937297821) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.22297777980566025) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24751372635364532) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617391228675842) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4298177510499954) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.3458903580904007) { + if (averageDuration_2 <= -0.3958975821733475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5875799059867859) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0415869653224945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5497413575649261) { + if (averageDuration_2 <= -0.36234311759471893) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5333283245563507) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (maxDuration_2 <= -0.3028547316789627) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5626251697540283) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45605458319187164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3926563858985901) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4628068208694458) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21553750336170197) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20022210478782654) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (averageDuration_2 <= -0.17413567006587982) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461606204509735) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485708594322205) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.031044652685523033) { + if (maxDuration_2 <= -0.35985802114009857) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4527949094772339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8376469910144806) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613345861434937) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.487790107727051) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24945639818906784) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (maxDuration_2 <= -0.42563460767269135) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3194351941347122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6070628464221954) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.24337955564260483) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.32716359198093414) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.0042311549186707) { + if (maxDuration_2 <= -0.4453490376472473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41970641911029816) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07804489508271217) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.10775989666581154) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46555641293525696) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5803781449794769) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21266233921051025) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (maxDuration_2 <= -0.08496975153684616) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485440373420715) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.1734088510274887) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (maxDuration_2 <= -0.10472219437360764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3118554800748825) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3284398019313812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0036615133285522) { + if (maxDuration_2 <= -0.08786974102258682) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28968849778175354) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533418208360672) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0711100734770298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1249871551990509) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5410707592964172) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (averageDuration_2 <= -0.4505794048309326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6884195506572723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15311185270547867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.08617021515965462) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0693339966237545) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7419182360172272) { + if (averageDuration_2 <= -0.4796365946531296) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0618066787719727) { + if (averageDuration_2 <= -0.5603125691413879) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18738047778606415) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1557490974664688) { + if (numDurations_2 <= 6.13090455532074) { + if (averageDuration_2 <= -0.5992408394813538) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (averageDuration_2 <= -0.6441903412342072) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233769893646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6844169795513153) { + if (maxDuration_2 <= -0.5782420039176941) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6848448216915131) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.650844156742096) { + if (averageDuration_2 <= -0.6270786225795746) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19176141172647476) { + if (averageDuration_2 <= -0.6318793892860413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485468983650208) { + if (maxDuration_2 <= -0.675710141658783) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6921019554138184) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6598462462425232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5853487253189087) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5878109335899353) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5718155205249786) { + if (maxDuration_2 <= -0.4557533860206604) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485237419605255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5207372307777405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7475999295711517) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (numDurations_2 <= 8.976664543151855) { + if (averageDuration_2 <= -0.7083494663238525) { + if (maxDuration_2 <= -0.6145963668823242) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (maxDuration_2 <= -0.7031999230384827) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2173927202820778) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28283192217350006) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7463460266590118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484782636165619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3082134872674942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4168335199356079) { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (averageDuration_2 <= -0.6237941980361938) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485337555408478) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6056435108184814) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6620512008666992) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32052081823349) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.47320613265037537) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (averageDuration_2 <= -0.6907609403133392) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5259695649147034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12618356943130493) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6325519979000092) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22981225699186325) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.4623687416315079) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3416352868080139) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4460074305534363) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1051611565053463) { + if (averageDuration_2 <= -0.5825749933719635) { + if (averageDuration_2 <= -0.6988268196582794) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482359409332275) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.458168163895607) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6953058838844299) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 6.415480613708496) { + if (maxDuration_2 <= -0.6085506975650787) { + if (averageDuration_2 <= -0.6439020931720734) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.717968076467514) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748550534248352) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6379198729991913) { + if (maxDuration_2 <= -0.4606516510248184) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.619862973690033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484246492385864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15533334761857986) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (averageDuration_2 <= -0.5787821412086487) { + if (maxDuration_2 <= -0.7166713774204254) { + if (averageDuration_2 <= -0.6765855550765991) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (averageDuration_2 <= -0.7119443416595459) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20668157190084457) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6402873992919922) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748564600944519) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31875666975975037) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06399912759661674) { + if (maxDuration_2 <= -0.5114751756191254) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1310025304555893) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.4957597106695175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2559058740735054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.600795567035675) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2668423652648926) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (averageDuration_2 <= -0.6890560388565063) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (averageDuration_2 <= -0.6005030870437622) { + if (averageDuration_2 <= -0.6944815814495087) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6913794279098511) { + if (averageDuration_2 <= -0.644711822271347) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6318919956684113) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2605709284543991) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5674171447753906) { + if (maxDuration_2 <= -0.6506591737270355) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2872399240732193) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6305203437805176) { + if (maxDuration_2 <= -0.6798838973045349) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.7350054085254669) { + if (maxDuration_2 <= -0.7414765357971191) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37743450701236725) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482427060604095) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4549897313117981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30007487535476685) { + if (maxDuration_2 <= -0.641447901725769) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3775891065597534) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485239803791046) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45882824063301086) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5103582739830017) { + if (averageDuration_2 <= -0.6077247262001038) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6201552152633667) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.705582857131958) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6956386864185333) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5928784608840942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36483073234558105) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6284285485744476) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (maxDuration_2 <= -0.7082425057888031) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3344017267227173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.620060920715332) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4195927232503891) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748570591211319) { + if (averageDuration_2 <= -0.6524563431739807) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7328249216079712) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485913038253784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3285861313343048) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4866477996110916) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6388697028160095) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.326301708817482) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7196970283985138) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7128343284130096) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006180226802826) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.6363495290279388) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (averageDuration_2 <= -0.5770213305950165) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.6162370443344116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486047148704529) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (averageDuration_2 <= -0.6232931613922119) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6631428301334381) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7465344667434692) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (maxDuration_2 <= -0.719897985458374) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6552769839763641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6391245424747467) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7164249420166016) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6667593717575073) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45215916633605957) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6639102697372437) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6393508911132812) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6562292575836182) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8171539902687073) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3736784756183624) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6379959583282471) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6697512865066528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6474349498748779) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.610166609287262) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7709015309810638) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5877041816711426) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35595713555812836) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3173746168613434) { + if (averageDuration_2 <= -0.5992724001407623) { + if (maxDuration_2 <= -0.6478936672210693) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (averageDuration_2 <= -0.7171596884727478) { + if (averageDuration_2 <= -0.7254830598831177) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4373031258583069) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1912640780210495) { + if (maxDuration_2 <= -0.7550998330116272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42268049716949463) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14663732051849365) { + if (averageDuration_2 <= -0.6037571430206299) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (numDurations_2 <= 6.13090455532074) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3671959787607193) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13406617939472198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6847387254238129) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01740696281194687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17010634392499924) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7089330554008484) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.7174064218997955) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.009127657394856215) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (averageDuration_2 <= -0.7136951982975006) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7479373216629028) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.7154228389263153) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484016120433807) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.04575827158987522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1190391443669796) { + if (averageDuration_2 <= -0.6405648291110992) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5516676604747772) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2619217783212662) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5947045087814331) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.190188705921173) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6929136514663696) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7240389585494995) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6351701617240906) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.599729597568512) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.605320006608963) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22908497601747513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29822908341884613) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000302791595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26695604622364044) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1129172332584858) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3451772928237915) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6156743764877319) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22087455540895462) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6578333377838135) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6883558630943298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5438152253627777) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01601999532431364) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088490307331085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 6.13090455532074) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1772996261715889) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25469575822353363) { + if (averageDuration_2 <= -0.6963765919208527) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (averageDuration_2 <= -0.6106477081775665) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (maxDuration_2 <= -0.6423773169517517) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11133436113595963) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (averageDuration_2 <= -0.5817033648490906) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (maxDuration_2 <= -0.707409143447876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (averageDuration_2 <= -0.5885096490383148) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6319730877876282) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09039109200239182) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (maxDuration_2 <= -0.6109693944454193) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6253879964351654) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.603890597820282) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486084997653961) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07622340321540833) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4310636818408966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6133097112178802) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485196888446808) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5795755684375763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6802361309528351) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40831059217453003) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.42058065533638) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27485162019729614) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.2258937805891037) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6886387169361115) { + if (maxDuration_2 <= -0.4476083368062973) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12272714078426361) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.477775514125824) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3461138904094696) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29962058365345) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5821956992149353) { + if (averageDuration_2 <= -0.6537623405456543) { + if (maxDuration_2 <= -0.37809085845947266) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15508370101451874) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3990137428045273) { + if (maxDuration_2 <= -0.5636664628982544) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32241390645504) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.29727524518966675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24407511949539185) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5848534405231476) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26164135336875916) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40059639513492584) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.425312876701355) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5955186784267426) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948375284671783) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.32677866518497467) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04892372526228428) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2672947496175766) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2733055055141449) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4480099380016327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5633839070796967) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998855829239) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485050857067108) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5814078450202942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13734575361013412) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (maxDuration_2 <= -0.4968235343694687) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.654631108045578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3919743448495865) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5644879043102264) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1644773706793785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6384816765785217) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5765884220600128) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (averageDuration_2 <= -0.5810084939002991) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15274066478013992) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (averageDuration_2 <= -0.5727010667324066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3660252094268799) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (maxDuration_2 <= -0.4368012547492981) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (averageDuration_2 <= -0.5803948044776917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3147025853395462) { + if (numDurations_2 <= -0.9834946841001511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5359943211078644) { + if (averageDuration_2 <= -0.5965176820755005) { + if (numDurations_2 <= 6.13090455532074) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24501170217990875) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.385641872882843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5726670324802399) { + if (maxDuration_2 <= -0.5782724320888519) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24444470554590225) { + if (averageDuration_2 <= -0.5863527655601501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5855134725570679) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748615950345993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6076204478740692) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2913016676902771) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.7059626579284668) { + if (averageDuration_2 <= -0.7074968814849854) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.016474337899126112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (averageDuration_2 <= -0.5784774720668793) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.668639749288559) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.387081116437912) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2942512184381485) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6306909620761871) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.48175404965877533) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.404605895280838) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485353946685791) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3778701722621918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4420737624168396) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.3631354570388794) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6306501626968384) { + if (maxDuration_2 <= -0.06621511653065681) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.060650864616036415) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (maxDuration_2 <= -0.15389452129602432) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2067742869257927) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488866329193) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (maxDuration_2 <= -0.5888818204402924) { + if (averageDuration_2 <= -0.5965440571308136) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (numDurations_2 <= 6.13090455532074) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07630449905991554) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (averageDuration_2 <= -0.7083695828914642) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45010609924793243) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.022631909232586622) { + if (averageDuration_2 <= -0.710541307926178) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6513368189334869) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1442170813679695) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22352147102355957) { + if (maxDuration_2 <= -0.6324492394924164) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6031441986560822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2892048507928848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3788013160228729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5981089174747467) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41282257437705994) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47287702560424805) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940378189087) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15348324179649353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05899206921458244) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1432473286986351) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6512995362281799) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3526008576154709) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6609622836112976) { + if (averageDuration_2 <= -0.6172437965869904) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6289971768856049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6209229230880737) { + if (averageDuration_2 <= -0.627981036901474) { + if (maxDuration_2 <= -0.7296184301376343) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483750879764557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2498645856976509) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6822977364063263) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2446881532669067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.665375143289566) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9391517639160156) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819160699844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11712650582194328) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17370933294296265) { + if (maxDuration_2 <= -0.634520947933197) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.609994649887085) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118843227625) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.60809725522995) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0043932057451456785) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6529995799064636) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (maxDuration_2 <= -0.6758011281490326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5995317697525024) { + if (averageDuration_2 <= -0.5742016136646271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5857761800289154) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6393659710884094) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22990572452545166) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (maxDuration_2 <= -0.6601163148880005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26355937123298645) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.6311676800251007) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.28807908296585083) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5566710829734802) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486057877540588) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (maxDuration_2 <= -0.4519239813089371) { + if (averageDuration_2 <= -0.6322380900382996) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484888136386871) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3260877653956413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (averageDuration_2 <= -0.6714364886283875) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18646074086427689) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6571762561798096) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4532155990600586) { + if (averageDuration_2 <= -0.5735413432121277) { + if (numDurations_2 <= 6.13090455532074) { + if (averageDuration_2 <= -0.6183644831180573) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (maxDuration_2 <= -0.5734679400920868) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6390793323516846) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24209287017583847) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2766965329647064) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5499264299869537) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6301092505455017) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2803422212600708) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6112167537212372) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4160782992839813) { + if (maxDuration_2 <= -0.13017592951655388) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02456360124051571) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484260201454163) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6396100521087646) { + if (averageDuration_2 <= -0.6314571499824524) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (maxDuration_2 <= -0.6232276558876038) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5380506217479706) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3189091086387634) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17654238641262054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7473077476024628) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (maxDuration_2 <= -0.4764505624771118) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6330539584159851) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.725941002368927) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20673715323209763) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (maxDuration_2 <= -0.6267683506011963) { + if (averageDuration_2 <= -0.6196272969245911) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27056601643562317) { + if (averageDuration_2 <= -0.6513076424598694) { + if (maxDuration_2 <= -0.6814112067222595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.66437628865242) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.755755752325058) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.5751760303974152) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6979712247848511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3417718708515167) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.30776816606521606) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (averageDuration_2 <= -0.6111786365509033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.58139568567276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6276070773601532) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (maxDuration_2 <= -0.2807570695877075) { + if (maxDuration_2 <= -0.6341030895709991) { + if (averageDuration_2 <= -0.6270729303359985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4963124692440033) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.57615065574646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5754052400588989) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4602256864309311) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.632216215133667) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5185667276382446) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5409769117832184) { + if (maxDuration_2 <= -0.6730633676052094) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.351614311337471) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578062057495) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2549879029393196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.27733276784420013) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5847499668598175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3549942225217819) { + if (numDurations_2 <= -0.9834946841001511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5944424867630005) { + if (averageDuration_2 <= -0.7077423334121704) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7239324450492859) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5793302059173584) { + if (averageDuration_2 <= -0.5952778160572052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7500903606414795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (averageDuration_2 <= -0.6413906812667847) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6661391258239746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.22047889977693558) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10000856593251228) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.479195833206177) { + if (averageDuration_2 <= -0.7038798332214355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5627588033676147) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6153299510478973) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.913651704788208) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5263607501983643) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7124274969100952) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (numDurations_2 <= 6.415480613708496) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2164584398269653) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748409241437912) { + if (averageDuration_2 <= -0.7140871286392212) { + if (maxDuration_2 <= -0.7719548940658569) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484433352947235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (maxDuration_2 <= -0.563701868057251) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6651031672954559) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.056468117982149124) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7477090358734131) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11920559778809547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (maxDuration_2 <= -0.5697320997714996) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3257780075073242) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3945978134870529) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.850115954875946) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21835432201623917) { + if (maxDuration_2 <= -0.7565460205078125) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5843615531921387) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.2638133466243744) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.518776923418045) { + if (maxDuration_2 <= -0.5615313053131104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5399122834205627) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04819197207689285) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05979132279753685) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0577878151088953) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182126104831696) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (averageDuration_2 <= -0.6158697605133057) { + if (numDurations_2 <= 6.13090455532074) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.346752107143402) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35619115829467773) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6555081903934479) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.48211367428302765) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06330370716750622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825266361236572) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8302063345909119) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3677114397287369) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.5886342525482178) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.2615691423416138) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.30358798801898956) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29676733911037445) { + if (maxDuration_2 <= -0.47296299040317535) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23138893395662308) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03231381718069315) { + if (maxDuration_2 <= -0.6112202107906342) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5869139432907104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.6821785569190979) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.309469535946846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31486302614212036) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12313800305128098) { + if (maxDuration_2 <= -0.4479603171348572) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20255523920059204) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7459561228752136) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.5777261853218079) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39037685096263885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (maxDuration_2 <= -0.5787991583347321) { + if (averageDuration_2 <= -0.6474884748458862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33143238723278046) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5596874952316284) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03922520764172077) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11987308040261269) { + if (averageDuration_2 <= -0.7153560817241669) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.25571219623088837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.27030202746391296) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (averageDuration_2 <= -0.6822157800197601) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (averageDuration_2 <= -0.5686883330345154) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03243057616055012) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8382551670074463) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.7029103636741638) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6102865934371948) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6678425371646881) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20619194209575653) { + if (maxDuration_2 <= -0.5121411979198456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.6585640013217926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12766677513718605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6652712225914001) { + if (maxDuration_2 <= -0.6405665278434753) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (averageDuration_2 <= -0.7103055715560913) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.86341992020607) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8883264660835266) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0258095264434814) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7776145040988922) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (maxDuration_2 <= -0.5265017151832581) { + if (averageDuration_2 <= -0.5748074650764465) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6531873643398285) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6031866371631622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5606751143932343) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4652512073516846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.4333643764257431) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1668703630566597) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6015757620334625) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (numDurations_2 <= -0.1297668218612671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.5090069472789764) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37704744935035706) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3945338577032089) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39162302017211914) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6396725177764893) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485932111740112) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4799177944660187) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (averageDuration_2 <= -0.5157861709594727) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4963555485010147) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (maxDuration_2 <= -0.523115336894989) { + if (numDurations_2 <= -0.9834946841001511) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21989356726408005) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07211801409721375) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6992646157741547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.514002114534378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3535720854997635) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5339557230472565) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.021550768986344337) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3575439304113388) { + if (averageDuration_2 <= -0.5053788423538208) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4008818417787552) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7465963959693909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.55132195353508) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.536685585975647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7300782799720764) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.0904808733612299) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5423820614814758) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6613061428070068) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485489249229431) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6020848155021667) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4501224458217621) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (maxDuration_2 <= -0.5426652431488037) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485353648662567) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748611718416214) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41778795421123505) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22760175913572311) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6238977313041687) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2172144055366516) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8477074503898621) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27458997070789337) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2008805200457573) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09641676023602486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5156345367431641) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485502362251282) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5403487384319305) { + if (maxDuration_2 <= -0.5728347599506378) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5546594858169556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5246325135231018) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.041432201862335205) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6140949130058289) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3001602292060852) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5303878486156464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.320826455950737) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (averageDuration_2 <= -0.5155457556247711) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (averageDuration_2 <= -0.5432513654232025) { + if (maxDuration_2 <= -0.5330384373664856) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.524500846862793) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.033411760814487934) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5188440382480621) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4751361012458801) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (maxDuration_2 <= -0.504801481962204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5019201040267944) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936677023768425) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5351015627384186) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4165748506784439) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (averageDuration_2 <= -0.5459118485450745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16147871315479279) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33931100368499756) { + if (averageDuration_2 <= -0.5472012460231781) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15178409218788147) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485724985599518) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6505235135555267) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485629916191101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (maxDuration_2 <= -0.49931828677654266) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5203522741794586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42465922236442566) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5095495581626892) { + if (averageDuration_2 <= -0.5018729418516159) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41188301146030426) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5394716262817383) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18903633207082748) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37186598777770996) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5261901021003723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (averageDuration_2 <= -0.5465414524078369) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06601044908165932) { + if (maxDuration_2 <= -0.49377672374248505) { + if (maxDuration_2 <= -0.49413132667541504) { + if (averageDuration_2 <= -0.4932745695114136) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7471111714839935) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5656722784042358) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04947089031338692) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3331745117902756) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35815654695034027) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08901536464691162) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4484865516424179) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5592569708824158) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5141507089138031) { + if (maxDuration_2 <= -0.6598884463310242) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4043412506580353) { + if (maxDuration_2 <= -0.5947931110858917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.5168949663639069) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5319100320339203) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (maxDuration_2 <= -0.6174859404563904) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3044580817222595) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (maxDuration_2 <= -0.5177308619022369) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33912962675094604) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2491239532828331) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.556867927312851) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5040348470211029) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3708195388317108) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.589312344789505) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5010989606380463) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5331955254077911) { + if (maxDuration_2 <= -0.5040240287780762) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310733318329) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2958206683397293) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4217275530099869) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6119897067546844) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37255190312862396) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48718151450157166) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5557412505149841) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5481290817260742) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6785764694213867) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3984972685575485) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5603882968425751) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (maxDuration_2 <= -0.570489376783371) { + if (averageDuration_2 <= -0.5336717665195465) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (averageDuration_2 <= -0.5392078459262848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.5380181074142456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4977605491876602) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35893236100673676) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.38399451971054077) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08076433464884758) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (maxDuration_2 <= -0.4746117442846298) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2721313089132309) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7019435465335846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17904957383871078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485529780387878) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10792580991983414) { + if (numDurations_2 <= 0.4393852949142456) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33317744731903076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (maxDuration_2 <= -0.5609033107757568) { + if (maxDuration_2 <= -0.6151078343391418) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.856589436531067) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02740886528044939) { + if (averageDuration_2 <= -0.52540123462677) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5648077130317688) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0336533784866333) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5795921385288239) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5170522034168243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (maxDuration_2 <= -0.6232731640338898) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9145718514919281) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5441612005233765) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40236958861351013) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.985200524330139) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1097114086151123) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5329894721508026) { + if (averageDuration_2 <= -0.5321161448955536) { + if (maxDuration_2 <= -0.4252496063709259) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (maxDuration_2 <= -0.3020593523979187) { + if (averageDuration_2 <= -0.5010087490081787) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08745496487244964) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (maxDuration_2 <= -0.38494184613227844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13690149411559105) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (averageDuration_2 <= -0.5077832937240601) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5176326632499695) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3339397609233856) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3228241354227066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18755441904067993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.206382632255554) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5189287960529327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.2392147183418274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5256039500236511) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4098938852548599) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5418279767036438) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331878066063) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5804793536663055) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (maxDuration_2 <= -0.4631108492612839) { + if (averageDuration_2 <= -0.5925170183181763) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.530704975128174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4391782879829407) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.15851354598999) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.8321900367736816) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6590698957443237) { + if (maxDuration_2 <= -0.5414976477622986) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27363070845603943) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4195858240127563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (maxDuration_2 <= -0.7442802488803864) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3148750364780426) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9705548286437988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.474243879318237) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16583268344402313) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4981125742197037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7543967962265015) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6060645282268524) { + if (averageDuration_2 <= -0.7158129215240479) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6415532827377319) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6945228576660156) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5400515496730804) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.1627421379089355) { + if (averageDuration_2 <= -0.6287789642810822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23781486600637436) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (averageDuration_2 <= -0.6292324662208557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23817314207553864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485694885253906) { + if (maxDuration_2 <= -0.6582167744636536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483588755130768) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2287803292274475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1570499762892723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6845675408840179) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.700544685125351) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48397035896778107) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621881961823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825266063213348) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855916082859) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43416035175323486) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6056584119796753) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.719211608171463) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6320083737373352) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485595047473907) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15086404234170914) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8064739406108856) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956273317337) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616482257843018) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6473364531993866) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4441741108894348) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.832190155982971) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6314084231853485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3253257274627686) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485034465789795) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8376701474189758) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5912991166114807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (maxDuration_2 <= -0.6019784510135651) { + if (maxDuration_2 <= -0.6525335311889648) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.289841890335083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4221771955490112) { + if (averageDuration_2 <= -0.7086963951587677) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0351535379886627) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3309372216463089) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5919741690158844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22585184127092361) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4515303075313568) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6578724682331085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5345251560211182) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5193747878074646) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6797472536563873) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.6402853429317474) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5949248671531677) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (averageDuration_2 <= -0.5593745410442352) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5445377230644226) { + if (maxDuration_2 <= -0.6143708825111389) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (maxDuration_2 <= -0.6022113859653473) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (maxDuration_2 <= -0.6599821150302887) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.369388163089752) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6157208383083344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5144805908203125) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461919903755188) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5047587752342224) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46994833648204803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.430754840373993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6636316776275635) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.740447610616684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608597159385681) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6412908136844635) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617987275123596) { + if (averageDuration_2 <= -0.5395024418830872) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6423529088497162) { + if (maxDuration_2 <= -0.623035192489624) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616658091545105) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6089862883090973) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5084951221942902) { + if (maxDuration_2 <= -0.6381757259368896) { + if (maxDuration_2 <= -0.6401056051254272) { + if (averageDuration_2 <= -0.5730026364326477) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4493311643600464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6284222602844238) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30496953427791595) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4594019055366516) { + if (maxDuration_2 <= -0.5022282600402832) { + if (cpuCoreIdleTimesPercentage_2_2 <= -3.014857053756714) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5064204633235931) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486071586608887) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5037727653980255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (maxDuration_2 <= -0.4612898677587509) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.11635999381542206) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6657199859619141) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5708335340023041) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5967322885990143) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.5062452554702759) { + if (maxDuration_2 <= -0.5075013935565948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5548197031021118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.48797938227653503) { + if (maxDuration_2 <= -0.4931486248970032) { + if (maxDuration_2 <= -0.49360957741737366) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4092605710029602) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5056869387626648) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5461997985839844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5259314477443695) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5845027267932892) { + if (maxDuration_2 <= -0.5898594260215759) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5247134268283844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461901307106018) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485643625259399) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4401201605796814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (averageDuration_2 <= -0.3643103986978531) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4706708490848541) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (averageDuration_2 <= -0.47107353806495667) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (maxDuration_2 <= -0.483347088098526) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.14702074229717255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9895455539226532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1014692522585392) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.614899069070816) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.12976670265197754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14334552735090256) { + if (numDurations_2 <= 0.15480925142765045) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2678428888320923) { + if (maxDuration_2 <= -0.4268401563167572) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3800019323825836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4700821340084076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.4362072944641113) { + if (maxDuration_2 <= -0.22508838772773743) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3296988308429718) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2657117396593094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9263713657855988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.459158182144165) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5120650827884674) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= -0.22536743432283401) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20997031778097153) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (maxDuration_2 <= -0.20090125501155853) { + if (maxDuration_2 <= -0.4472789466381073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.25260934233665466) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7447181642055511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485988736152649) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3967061936855316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09356221556663513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17090608179569244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.2673764079809189) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2166208252310753) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11075641959905624) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.30099768936634064) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29941584169864655) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485513687133789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5235314071178436) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.23330730199813843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0755597352981567) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.299454927444458) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1704033762216568) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21382441371679306) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (averageDuration_2 <= -0.0449118260294199) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10823847725987434) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.28165359795093536) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12319125235080719) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1259622573852539) { + if (averageDuration_2 <= -0.17545931786298752) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.1256220079958439) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.029448035173118114) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.21904607117176056) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06286668963730335) { + if (maxDuration_2 <= -0.29095615446567535) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.20240458101034164) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02252345345914364) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998483300209) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (maxDuration_2 <= -0.18354210257530212) { + if (averageDuration_2 <= -0.18870840221643448) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.32316190004348755) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3202188313007355) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (maxDuration_2 <= -0.18496549874544144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.19264373928308487) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748577356338501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (maxDuration_2 <= -0.1073739156126976) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23567409813404083) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.16509276628494263) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (maxDuration_2 <= -0.08689983561635017) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.054554807022213936) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478991150856018) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41117388010025024) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2760425806045532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19360028952360153) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07256471738219261) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2711581438779831) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3197200149297714) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4811157286167145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (averageDuration_2 <= -0.24051138758659363) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.419434368610382) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2010168433189392) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5417449176311493) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5404199957847595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.2831329107284546) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7624516487121582) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2829435467720032) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.052657850086688995) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5307832658290863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4570999145507812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17854981124401093) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.376688003540039) { + if (averageDuration_2 <= -0.2118023931980133) { + if (averageDuration_2 <= -0.2137259840965271) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.11583025008440018) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.790669322013855) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2761373966932297) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665165930986404) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19004305452108383) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8387757241725922) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5792726874351501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (averageDuration_2 <= -0.15520743280649185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.527993343770504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3311299979686737) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.29653505980968475) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.452691376209259) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.33287017047405243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5400526225566864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6254423558712006) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.4599164128303528) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5909016728401184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19416650384664536) { + if (maxDuration_2 <= -0.3163464069366455) { + if (averageDuration_2 <= -0.4182475209236145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (averageDuration_2 <= -0.19587955623865128) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47822894155979156) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1627480387687683) { + if (averageDuration_2 <= -0.23158440738916397) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.24310090392827988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.33763113617897034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.23783621191978455) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.217767596244812) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21405158936977386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485164403915405) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486236691474915) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.36404065787792206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.605915755033493) { + if (averageDuration_2 <= -0.21702267229557037) { + if (averageDuration_2 <= -0.39489197731018066) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16068629175424576) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= -0.2548810988664627) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42635399103164673) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09712367877364159) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3081279993057251) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.38210777938365936) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485395669937134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2587413787841797) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18581652641296387) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (maxDuration_2 <= -0.15951956808567047) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4520125687122345) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486122846603394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.38568535447120667) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29812364280223846) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.36859849095344543) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.45106177031993866) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4294846057891846) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.16245748847723007) { + if (maxDuration_2 <= -0.4652763605117798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4268300384283066) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091154009103775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8936700522899628) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16712819039821625) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.44695231318473816) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4062532037496567) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4421443939208984) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (maxDuration_2 <= -0.3288401961326599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4742417633533478) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.42441636323928833) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0936996228992939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614782333374023) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.320826455950737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.456036314368248) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.3758874088525772) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22147665172815323) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.390625) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7240137457847595) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.175323273986578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40219008922576904) { + if (averageDuration_2 <= 0.0005997614935040474) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6279810667037964) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616716504096985) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486147284507751) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0478596817702055) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748522937297821) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.06562501564621925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26456184685230255) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26996414363384247) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.2901812344789505) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.5609686970710754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.0812260508537292) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2918991446495056) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.006857895525172353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5420771241188049) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199911594391) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.21609492599964142) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614869952201843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3974560350179672) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5633972883224487) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4125909209251404) { + if (maxDuration_2 <= -0.32084693014621735) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + if (averageDuration_2 <= -0.45444852113723755) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.10971175134181976) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337136715650558) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47296473383903503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3481670022010803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13226541131734848) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.286694660782814) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.34946462512016296) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4170728772878647) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485511004924774) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.019017704762518406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.45277389883995056) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0362901985645294) { + if (maxDuration_2 <= -0.3497324436903) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5723944306373596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24440757185220718) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (averageDuration_2 <= -0.2888507544994354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.032543187378905714) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6669449806213379) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7114445269107819) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06499477289617062) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8369991779327393) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2987431287765503) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (maxDuration_2 <= -0.5567596852779388) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4457963556051254) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461283802986145) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.648976445198059) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.16854366660118103) { + if (maxDuration_2 <= -0.44621536135673523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41196922957897186) { + if (maxDuration_2 <= -0.45157942175865173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485196888446808) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22892621904611588) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8058932423591614) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34377241134643555) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15110697597265244) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4085633307695389) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485462427139282) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.39113272726535797) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615954756736755) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2243993803858757) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5635370314121246) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (maxDuration_2 <= -0.24272357672452927) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485405802726746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461799681186676) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2605958729982376) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3060985952615738) { + if (maxDuration_2 <= -0.4404990077018738) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485395967960358) { + if (averageDuration_2 <= -0.31655801832675934) { + if (averageDuration_2 <= -0.4201143980026245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485221326351166) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460499584675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485952079296112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486082315444946) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.07992473244667053) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27866485714912415) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24115795642137527) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2925875037908554) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2904955744743347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4649350345134735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.34949256479740143) { + if (averageDuration_2 <= -0.4578302204608917) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2420012503862381) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (averageDuration_2 <= -0.41511140763759613) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36757953464984894) { + if (averageDuration_2 <= -0.44762371480464935) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3546786457300186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4016246497631073) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3726281225681305) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33423367142677307) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4239456206560135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.35669392347335815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.3132963925600052) { + if (maxDuration_2 <= -0.46219155192375183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.33621934056282043) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32631050050258636) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6730119585990906) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4382731020450592) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4082258641719818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.47392043471336365) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33492837846279144) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485816776752472) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (maxDuration_2 <= -0.1570020690560341) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3744259476661682) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.46464112401008606) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2640967518091202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7942454218864441) { + if (averageDuration_2 <= -0.21374227106571198) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16492976248264313) { + if (averageDuration_2 <= -0.24888796359300613) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (averageDuration_2 <= -0.27414843440055847) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01227972423657775) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27628175914287567) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19508984684944153) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7014470100402832) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (maxDuration_2 <= -0.15677406638860703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6438708007335663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07319054007530212) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3009806275367737) { + if (averageDuration_2 <= -0.28228411078453064) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6141973733901978) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6163232624530792) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18555010110139847) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.46791939437389374) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3559087887406349) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1873953491449356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7867609560489655) { + if (averageDuration_2 <= -0.3722701668739319) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1783582866191864) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4043188989162445) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.2481725662946701) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { + if (maxDuration_2 <= -0.3503655940294266) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.2897071987390518) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (averageDuration_2 <= -0.25477904081344604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3122410178184509) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.35789524018764496) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (maxDuration_2 <= -0.2122957780957222) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2276564985513687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20796751230955124) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4214019775390625) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.3955571800470352) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5449985563755035) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6771047115325928) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43062810599803925) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (maxDuration_2 <= -0.5373972058296204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0108683109283447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.17726513743400574) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406549453735) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272986829280853) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9160395562648773) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46368658542633057) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4499184191226959) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5275512933731079) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.446727216243744) { + if (maxDuration_2 <= -0.4543781578540802) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618290066719055) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.121818721294403) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4254775643348694) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.45941805839538574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16412602365016937) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3735408186912537) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5682035982608795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.4275415986776352) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.455130159854889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6892416775226593) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616824388504028) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6838820278644562) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1380702555179596) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3385528177022934) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3520589768886566) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (averageDuration_2 <= -0.3757459223270416) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3763286918401718) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6957041025161743) { + if (averageDuration_2 <= -0.3888409733772278) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2830542027950287) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.33243660628795624) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4866507649421692) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30060437321662903) { + if (averageDuration_2 <= -0.45740102231502533) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613903164863586) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5532271564006805) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20996110141277313) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { + if (maxDuration_2 <= -0.2342694029211998) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.39264850318431854) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48412199318408966) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288967967033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.17275911569595337) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.1897422820329666) { + if (maxDuration_2 <= -0.4273213893175125) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484985888004303) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.701122909784317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615759253501892) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13907665759325027) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8327971994876862) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615427255630493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.5560935735702515) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19504929333925247) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2886967360973358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5478068292140961) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616726636886597) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4161391705274582) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.280378594994545) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2704838663339615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481509149074554) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13706288486719131) { + if (maxDuration_2 <= -0.3742387145757675) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6121544539928436) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.47511574625968933) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13414227962493896) { + if (averageDuration_2 <= -0.4588353633880615) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4605910181999207) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25763140618801117) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.46432772278785706) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (maxDuration_2 <= -0.3286426067352295) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45194506645202637) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4760628193616867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37610098719596863) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7022022008895874) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5717683434486389) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615514874458313) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485684156417847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4610670804977417) { + if (averageDuration_2 <= -0.4672704190015793) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.13219693303108215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.41715510189533234) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5403721332550049) { + if (averageDuration_2 <= -0.0015529347583651543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2000451162457466) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4818741977214813) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2417157217860222) { + if (averageDuration_2 <= -0.3829553723335266) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2543259412050247) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.35119329392910004) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818998217583) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (averageDuration_2 <= -0.42565564811229706) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.16291839629411697) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.40711306035518646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1031596027314663) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19247859716415405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24851423501968384) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5046090483665466) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345905259251595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32680052518844604) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (averageDuration_2 <= -0.3734745681285858) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04137381166219711) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7186876237392426) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9710132777690887) { + if (averageDuration_2 <= -0.3728286921977997) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5602262616157532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5035108029842377) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550041913986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (maxDuration_2 <= -0.47628600895404816) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6598224937915802) { + if (averageDuration_2 <= -0.433050736784935) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3246244639158249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4072634279727936) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5026872158050537) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24944493174552917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.12023483589291573) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.33005325496196747) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.05928822420537472) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (averageDuration_2 <= -0.4457721710205078) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6012653335928917) { + if (maxDuration_2 <= -0.10277709364891052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9738087058067322) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40085650980472565) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (averageDuration_2 <= -0.2254275307059288) { + if (maxDuration_2 <= -0.19366789609193802) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5949988663196564) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3833676874637604) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.6086798906326294) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.2150048017501831) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (averageDuration_2 <= -0.36736442148685455) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (averageDuration_2 <= -0.23991858214139938) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.22675355523824692) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484709620475769) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9049322307109833) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25466300547122955) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5851186215877533) { + if (maxDuration_2 <= -0.30136051774024963) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334688901901245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.910904288291931) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.3926389813423157) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.005700349574908614) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617830514907837) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.018405020236969) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5121813416481018) { + if (maxDuration_2 <= -0.7903296053409576) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.023051044903695583) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7823136746883392) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.30492761731147766) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.003652036713901907) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4427055716514587) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7424591183662415) { + if (averageDuration_2 <= 0.05751620605587959) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335726141929626) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3715622425079346) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (maxDuration_2 <= -0.23854973167181015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.42595982551574707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7920783758163452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12868332117795944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10699904710054398) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (maxDuration_2 <= -0.1915656514465809) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4441435933113098) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1833718866109848) { + if (averageDuration_2 <= -0.5193924009799957) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8832673728466034) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.045107850804924965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1979415714740753) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2001994326710701) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5818384885787964) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7200384140014648) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643927812576294) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.42821288108825684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4301474839448929) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6887571215629578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.015191368293017149) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5700184106826782) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4803755283355713) { + if (maxDuration_2 <= -0.6873755753040314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6279993653297424) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5964350700378418) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.274163581430912) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5308651030063629) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28999821841716766) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.020174313336610794) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21295372396707535) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7329195737838745) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7397380769252777) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.524916410446167) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4010290205478668) { + if (maxDuration_2 <= -0.5428045392036438) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3895687609910965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3035068064928055) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23857007920742035) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6204427778720856) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.43432486057281494) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4687822759151459) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.5816560387611389) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33300548791885376) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4426897317171097) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36191636323928833) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (maxDuration_2 <= -0.464225172996521) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.27163177728652954) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5787796974182129) { + if (averageDuration_2 <= -0.6922681033611298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3939834535121918) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.562934935092926) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (averageDuration_2 <= -0.6572836637496948) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6339364051818848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6799893081188202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.636779397726059) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.331957072019577) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42107343673706055) { + if (maxDuration_2 <= -0.4922596514225006) { + if (averageDuration_2 <= -0.6064842939376831) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2955031096935272) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3545657843351364) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6670986115932465) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.45866842567920685) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6327858865261078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5110780000686646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0788019672036171) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (maxDuration_2 <= -0.36035455763339996) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6907223761081696) { + if (averageDuration_2 <= -0.47336338460445404) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31011928617954254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5201195478439331) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3351140320301056) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.471996933221817) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3458111137151718) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38032156229019165) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3007252961397171) { + if (averageDuration_2 <= -0.44142450392246246) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3655364513397217) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4022200405597687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4199192374944687) { + if (averageDuration_2 <= -0.39238764345645905) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 0.7239612638950348) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5951146483421326) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37378986179828644) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33352920413017273) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24393915385007858) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.4866066426038742) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6813062429428101) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.477549284696579) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4143700450658798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5347775220870972) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4308469146490097) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5092711746692657) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10309367999434471) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.42986324429512024) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5962875783443451) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.316741943359375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= -0.40066154301166534) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6635134220123291) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.45369045436382294) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.252274326980114) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.2816295474767685) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7266050279140472) { + if (averageDuration_2 <= -0.5566121339797974) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107351958751678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7094330191612244) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3368610441684723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3445131182670593) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6385188698768616) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5960135459899902) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (averageDuration_2 <= -0.6073680222034454) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3374057561159134) { + if (averageDuration_2 <= -0.6791125535964966) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6555702686309814) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6413910686969757) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07195151224732399) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35522042214870453) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3807809203863144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1838994361460209) { + if (averageDuration_2 <= -0.6342234015464783) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.24957452714443207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (maxDuration_2 <= -0.43396466970443726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5381674468517303) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6953891515731812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05951779894530773) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (maxDuration_2 <= -0.37669797241687775) { + if (maxDuration_2 <= -0.43521587550640106) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3639540523290634) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5326409637928009) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.27426286041736603) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.34191402792930603) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4458917826414108) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6082741916179657) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0030868298490531743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3829773813486099) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058830752968788) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3807242214679718) { + if (averageDuration_2 <= -0.3870433568954468) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6156572103500366) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37306079268455505) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7490861415863037) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.330244243144989) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33612529933452606) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3602338284254074) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.4206695258617401) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.19592706114053726) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4018948972225189) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.43154850602149963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1155618317425251) { + if (averageDuration_2 <= -0.572259247303009) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06071211397647858) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01564787235110998) { + if (maxDuration_2 <= -0.2510637864470482) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4279359132051468) { + if (maxDuration_2 <= -0.49300433695316315) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.41974852979183197) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.598107099533081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2427278533577919) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3297087997198105) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5438234806060791) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5239328145980835) { + if (maxDuration_2 <= -0.5626051127910614) { + if (averageDuration_2 <= -0.7148647606372833) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.590447872877121) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6709553301334381) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44993625581264496) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.391630083322525) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.6912834048271179) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (averageDuration_2 <= -0.4088483601808548) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08886208385229111) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5925875306129456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (maxDuration_2 <= -0.5083319842815399) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35775986313819885) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4711952954530716) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2941840589046478) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5504738688468933) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.41210000216960907) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0789777934551239) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (numDurations_2 <= -0.12976674735546112) { + if (maxDuration_2 <= -0.4678063988685608) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04061266127973795) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4472324103116989) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6555571258068085) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.34748217463493347) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.4100559651851654) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6095859706401825) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5000573396682739) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (averageDuration_2 <= -0.6975497305393219) { + if (maxDuration_2 <= -0.6828142404556274) { + if (maxDuration_2 <= -0.7542589604854584) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.700643002986908) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6399409472942352) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (averageDuration_2 <= -0.6642254889011383) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42756858468055725) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.614367663860321) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172387123108) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6742609739303589) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (maxDuration_2 <= -0.553758442401886) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5281822979450226) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40604346990585327) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5494554042816162) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6584278643131256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.46818894147872925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01600167527794838) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7279769778251648) { + if (maxDuration_2 <= -0.2094743326306343) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.170930914580822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2582723796367645) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5778598785400391) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4714936912059784) { + if (maxDuration_2 <= -0.36992570757865906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.5642429888248444) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6778405904769897) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (maxDuration_2 <= -0.5181893110275269) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3816138505935669) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.32011324167251587) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1854533702135086) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24568882584571838) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3937246799468994) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5466974377632141) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.536464512348175) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.4338659942150116) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (averageDuration_2 <= -0.5785888135433197) { + if (maxDuration_2 <= -0.5675082802772522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.268677219748497) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4277891665697098) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.47503477334976196) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (averageDuration_2 <= -0.572611540555954) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5477648973464966) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6135604381561279) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5900779068470001) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2688600420951843) { + if (averageDuration_2 <= -0.5204283595085144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5393828749656677) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1613878384232521) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1798400655388832) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6078041791915894) { + if (averageDuration_2 <= -0.5489970743656158) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25782211869955063) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5195886194705963) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4512515366077423) { + if (maxDuration_2 <= -0.37135404348373413) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620584785938263) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6007876694202423) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2672463357448578) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11300480738282204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.004863670794293284) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.19438471645116806) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.4430191069841385) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4221530854701996) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6727392673492432) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044969316571951) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (averageDuration_2 <= -0.2608429938554764) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.033641671761870384) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2721599042415619) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (averageDuration_2 <= -0.6125730276107788) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4767304062843323) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (averageDuration_2 <= -0.1767900437116623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.44919373095035553) { + if (maxDuration_2 <= -0.5613007545471191) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10508787631988525) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2837759405374527) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2163441851735115) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.906676322221756) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3239317834377289) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2927061915397644) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.26925601065158844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5094412565231323) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (averageDuration_2 <= -0.23828575015068054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19115804135799408) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21616746485233307) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3871554285287857) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.665979266166687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.579567551612854) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4474821835756302) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5366528332233429) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (maxDuration_2 <= -0.5057031214237213) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.392794594168663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.6275711953639984) { + if (averageDuration_2 <= -0.6559590399265289) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7214200794696808) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08328690379858017) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0784654021263123) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5877139270305634) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16673003137111664) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4025792181491852) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2150450497865677) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6270575225353241) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.34413181245326996) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8296964168548584) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4720006436109543) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.45055627822875977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18484122306108475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (maxDuration_2 <= -0.33969278633594513) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7617704272270203) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6711086630821228) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5343524217605591) { + if (averageDuration_2 <= -0.4998858720064163) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5960211753845215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2581060528755188) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.35267578065395355) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.44012220203876495) { + if (maxDuration_2 <= -0.6486711502075195) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06571878865361214) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04898570477962494) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2621278613805771) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6370247900485992) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28558778762817383) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08094102516770363) { + if (maxDuration_2 <= -0.5303766131401062) { + if (averageDuration_2 <= -0.5438317954540253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2595761716365814) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07090604677796364) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.021090074442327023) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3657643347978592) { + if (averageDuration_2 <= -0.5320875942707062) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6902958750724792) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.32123707234859467) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5868276953697205) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.739741712808609) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (averageDuration_2 <= -0.5182605385780334) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21980562806129456) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.036989739164710045) { + if (averageDuration_2 <= -0.5966008603572845) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35888415575027466) { + if (averageDuration_2 <= -0.643396258354187) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3355884402990341) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06001227721571922) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1409154310822487) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4425361007452011) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24444666504859924) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (maxDuration_2 <= -0.36216023564338684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.37922661006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.4357266277074814) { + if (averageDuration_2 <= -0.5775186419487) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.38081102073192596) { + if (maxDuration_2 <= -0.5711554288864136) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (maxDuration_2 <= -0.33815787732601166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0849049799144268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6564563512802124) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (maxDuration_2 <= -0.4514883756637573) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (averageDuration_2 <= -0.3613964319229126) { + if (averageDuration_2 <= -0.5418146252632141) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10393516346812248) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6286424100399017) { + if (maxDuration_2 <= -0.6853621900081635) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5553404688835144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06623053550720215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6437544524669647) { + if (averageDuration_2 <= -0.6896811425685883) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6052533686161041) { + if (maxDuration_2 <= -0.6761102676391602) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46444711089134216) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20521094650030136) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.46684595942497253) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (numDurations_2 <= 6.415480613708496) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5115936994552612) { + if (averageDuration_2 <= -0.5521532595157623) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44664424657821655) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2622973173856735) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.037421513348817825) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2778159976005554) { + if (averageDuration_2 <= -0.5787172019481659) { + if (maxDuration_2 <= -0.5880028903484344) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9917370676994324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5603117048740387) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14540570229291916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.417084276676178) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.002271471719723195) { + if (averageDuration_2 <= -0.4696533530950546) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6409636735916138) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3494008481502533) { + if (averageDuration_2 <= -0.5885285437107086) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5721043944358826) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014292513951659203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.03808201104402542) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (averageDuration_2 <= -0.3874456286430359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.41481491923332214) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09638939797878265) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998483300209) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4384583383798599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= -0.6362746953964233) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5665238499641418) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26830294728279114) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.44997090101242065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0009006254840642214) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2190776988863945) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.08691485226154327) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12777741998434067) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5167746245861053) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.39400604367256165) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26201753318309784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.31058867275714874) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4645035117864609) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.46429693698883057) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36785009503364563) { + if (averageDuration_2 <= -0.5766976177692413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4858788698911667) { + if (maxDuration_2 <= -0.6100626289844513) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (averageDuration_2 <= -0.6592468023300171) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6565076410770416) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5002553462982178) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5439257919788361) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (maxDuration_2 <= -0.5685215294361115) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19475125521421432) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14846592396497726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15156816691160202) { + if (maxDuration_2 <= -0.5501189231872559) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.6909684836864471) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.030633222311735153) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (averageDuration_2 <= -0.5145505964756012) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10413570702075958) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.017127064522355795) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13329769670963287) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194464087486267) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (maxDuration_2 <= -0.3275230824947357) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08422081917524338) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.42709319293498993) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2384834811091423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4711695462465286) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1938801109790802) { + if (averageDuration_2 <= -0.5716152489185333) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2029411792755127) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5037308931350708) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.00383871141821146) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6405423581600189) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620310544968) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2856951951980591) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6067191958427429) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1135147251188755) { + if (maxDuration_2 <= -0.4321385622024536) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6734523177146912) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6098056435585022) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09415304660797119) { + if (averageDuration_2 <= -0.5231500566005707) { + if (maxDuration_2 <= -0.48908616602420807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.015389776788651943) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5329292118549347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5890832543373108) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13458647578954697) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (averageDuration_2 <= -0.627736359834671) { + if (numDurations_2 <= 6.13090455532074) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35789404809474945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2279456928372383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984920978546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1695406138896942) { + if (averageDuration_2 <= -0.3964981287717819) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12222980335354805) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.48460327088832855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2669837027788162) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (averageDuration_2 <= -0.3028763234615326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3655228763818741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.04324875585734844) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5998486578464508) { + if (averageDuration_2 <= -0.4220292568206787) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.024110945872962475) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08181719854474068) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.39840173721313477) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14458885788917542) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16259515285491943) { + if (averageDuration_2 <= -0.5329953134059906) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48120370507240295) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.40954066812992096) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5742352902889252) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30490411818027496) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4038868546485901) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5030182898044586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6649013757705688) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4029061496257782) { + if (averageDuration_2 <= -0.401882067322731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2946203202009201) { + if (maxDuration_2 <= -0.49771758913993835) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4577980041503906) { + if (averageDuration_2 <= -0.4480356276035309) { + if (maxDuration_2 <= -0.47275274991989136) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (averageDuration_2 <= -0.6368124485015869) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.572639673948288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2916236072778702) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (maxDuration_2 <= -0.2805873602628708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2693729996681213) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (maxDuration_2 <= -0.6950142681598663) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28805598616600037) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49122045934200287) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04185870848596096) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6419226229190826) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6470335423946381) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6789924502372742) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.015015913872048259) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4128846228122711) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34566009044647217) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15272027999162674) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + if (maxDuration_2 <= -0.3554309606552124) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26742714643478394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.33801865577697754) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4940330237150192) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4132893681526184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.7311380207538605) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14812824875116348) { + if (averageDuration_2 <= -0.5781367123126984) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03422987461090088) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5935510396957397) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46902066469192505) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.49560022354125977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 1.2931132316589355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.623184859752655) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1371224895119667) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11718219891190529) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.31149403750896454) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.37020328640937805) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08024165034294128) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (maxDuration_2 <= -0.6338092684745789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + if (maxDuration_2 <= -0.374144971370697) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.07610019110143185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (averageDuration_2 <= -0.33539286255836487) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7049064338207245) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6383807063102722) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 0.7239611893892288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.3005373626947403) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35788053274154663) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.575544685125351) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25935156643390656) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4452284276485443) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4789285510778427) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7512213289737701) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7542689442634583) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5737413465976715) { + if (maxDuration_2 <= -0.482759490609169) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6155956089496613) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4726017415523529) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5564692914485931) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.49777135252952576) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + if (maxDuration_2 <= -0.31172432750463486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (averageDuration_2 <= -0.6697492599487305) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6210143864154816) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (averageDuration_2 <= -0.4282228648662567) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337137460708618) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.6282018423080444) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.27106189727783203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.3464677184820175) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.6764321029186249) { + if (maxDuration_2 <= -0.7053755521774292) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.6093282997608185) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16962024569511414) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.581450879573822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.129171907901764) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6802070140838623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5344770848751068) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.325662225484848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.18521414697170258) { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4876602739095688) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43547120690345764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.057664165273308754) { + if (averageDuration_2 <= -0.49211832880973816) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (averageDuration_2 <= -0.6956366002559662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3588019162416458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6209022700786591) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8833414316177368) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.544114351272583) { + if (averageDuration_2 <= -0.3913480341434479) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (maxDuration_2 <= -0.6970532834529877) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.35665421187877655) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2944568395614624) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2971375286579132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7020067870616913) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4603101760149002) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.45012256503105164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2707738131284714) { + if (maxDuration_2 <= -0.7486161291599274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12442409247159958) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8631931245326996) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5640234649181366) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5086512267589569) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (maxDuration_2 <= -0.6432662904262543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015798807144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4628477990627289) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08515290357172489) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.1498548611998558) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6260631680488586) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9485477358102798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2561350241303444) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (maxDuration_2 <= -0.3928362876176834) { + if (maxDuration_2 <= -0.39352773129940033) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37085163593292236) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0482568144798279) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.20400377362966537) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16399110853672028) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.263237863779068) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3462238162755966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06704606674611568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2150970920920372) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06135031580924988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4219494462013245) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= -0.23174943774938583) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0020591020584106) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { + if (maxDuration_2 <= -0.3818267434835434) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287291735411) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9794953167438507) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (maxDuration_2 <= -0.3376590311527252) { + if (averageDuration_2 <= -0.6083321273326874) { + if (averageDuration_2 <= -0.665192037820816) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.7017943561077118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5871392786502838) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3802126497030258) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5472888648509979) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2788807153701782) { + if (averageDuration_2 <= -0.5075477063655853) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2609674781560898) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6879418194293976) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6728918254375458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (averageDuration_2 <= -0.6162255108356476) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32162290811538696) { + if (averageDuration_2 <= -0.5548312962055206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1968777179718018) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0135681629180908) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.304485559463501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.60867977142334) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.48292990028858185) { + if (averageDuration_2 <= -0.4962081164121628) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3941240906715393) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20299670100212097) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4027926921844482) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32479988038539886) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (averageDuration_2 <= -0.2988421469926834) { + if (maxDuration_2 <= -0.7058844566345215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1562942266464233) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6658270061016083) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5903565883636475) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5541948974132538) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6616465747356415) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.3351440578699112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.265440344810486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14685963094234467) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.739947646856308) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0033265510573983192) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4544153958559036) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6878706216812134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49702271819114685) { + if (averageDuration_2 <= -0.17363857477903366) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0919133834540844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5462964177131653) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.227171003818512) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2663988620042801) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9773139953613281) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9766207337379456) { + if (averageDuration_2 <= -0.6290794909000397) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1660279557108879) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2826306819915771) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6754916608333588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.3219284117221832) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5202487111091614) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6598967909812927) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (maxDuration_2 <= -0.616695910692215) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5848664939403534) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.795640379190445) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.91457799077034) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5497745871543884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5486096143722534) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.573926568031311) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392720937729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.312289834022522) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06420418247580528) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5555276572704315) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6134804487228394) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.002244919538498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3222681134939194) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5274057388305664) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.385944604873657) { + if (averageDuration_2 <= -0.40215201675891876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3846283257007599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17287343740463257) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13254066184163094) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17611654847860336) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5272400677204132) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.7237207889556885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4865536093711853) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2931492328643799) { + if (averageDuration_2 <= -0.5599842667579651) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5535230040550232) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22954900562763214) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614850878715515) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.63819819688797) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287291735411) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614684581756592) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5169931650161743) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4467995762825012) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (maxDuration_2 <= -0.6377780437469482) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6436245739459991) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6710196137428284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.4972262531518936) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (averageDuration_2 <= -0.5405691564083099) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42958447337150574) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6592608392238617) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4424368143081665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4301568269729614) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6503072082996368) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.5046433508396149) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615730047225952) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6310891807079315) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462371289730072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6782723069190979) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3127615451812744) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21941764652729034) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.32608775794506073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.902929961681366) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.641698569059372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5813411176204681) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3610436916351318) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0641183853149414) { + if (averageDuration_2 <= -0.5865824818611145) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.508173018693924) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17320384085178375) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5615793466567993) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855916082859) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2640686184167862) { + if (averageDuration_2 <= -0.6069186627864838) { + if (averageDuration_2 <= -0.6855879724025726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5218642354011536) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110842227936) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 1.2931131720542908) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8369036614894867) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4628353714942932) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.293113186955452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1085416674613953) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5567216873168945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.056986391544342) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (maxDuration_2 <= -0.5636104643344879) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1968777179718018) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5319747030735016) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615075588226318) { + if (averageDuration_2 <= -0.6808962821960449) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.351614311337471) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6054674386978149) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10893140360713005) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.4015178084373474) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614977836608887) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4787839651107788) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462165117263794) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617830514907837) { + if (maxDuration_2 <= -0.4910465031862259) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5145916938781738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4686397910118103) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16116946190595627) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4992072731256485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5706000626087189) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08108561113476753) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12788648158311844) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.23600031435489655) { + if (averageDuration_2 <= -0.42968253791332245) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6487915813922882) { + if (averageDuration_2 <= -0.4606994390487671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676986515522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4381866306066513) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5651591718196869) { + if (averageDuration_2 <= -0.47095203399658203) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6998036801815033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38320714235305786) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.592125415802002) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (maxDuration_2 <= -0.20241829007863998) { + if (averageDuration_2 <= -0.24866830557584763) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6617604494094849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.3630341440439224) { + if (averageDuration_2 <= -0.30623771250247955) { + if (maxDuration_2 <= -0.46328045427799225) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27994371950626373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44931818544864655) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.575957715511322) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.20027821511030197) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5018746107816696) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581474900245667) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.29195816814899445) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.18144676834344864) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4637082368135452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (maxDuration_2 <= -0.44950273633003235) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30005913972854614) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.36732906103134155) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3245236277580261) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.33579234778881073) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.31918296217918396) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3215075731277466) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3046439588069916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.40452656149864197) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.16960474103689194) { + if (averageDuration_2 <= -0.34044039249420166) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.20192205905914307) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.467544361948967) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4192776083946228) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21545574814081192) { + if (maxDuration_2 <= -0.395708292722702) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3953486680984497) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461483120918274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3388783782720566) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616110920906067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8376701474189758) { + if (maxDuration_2 <= -0.37811627984046936) { + if (averageDuration_2 <= -0.3325899839401245) { + if (maxDuration_2 <= -0.5060120522975922) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1613166406750679) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48433348536491394) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.14496919512748718) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2675982862710953) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5070698261260986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4451569616794586) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3247508108615875) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.3267330527305603) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.43168850243091583) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7001699805259705) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (maxDuration_2 <= -0.1361098736524582) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749723672867) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5039820671081543) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (averageDuration_2 <= -0.3366616368293762) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.11954253911972046) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (maxDuration_2 <= -0.2872660458087921) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22695939242839813) { + if (averageDuration_2 <= -0.2723873108625412) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5861169695854187) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22482605278491974) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.08823974430561066) { + if (maxDuration_2 <= -0.42012348771095276) { + if (averageDuration_2 <= -0.39200618863105774) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23545221984386444) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4355650544166565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.44009384512901306) { + if (maxDuration_2 <= -0.5560302138328552) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5405048429965973) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12205103412270546) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (averageDuration_2 <= -0.4649752229452133) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24163713306188583) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3992937356233597) { + if (averageDuration_2 <= -0.44988226890563965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.498771011829376) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4537514448165894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12860267609357834) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0610276535153389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3317403793334961) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.4926325976848602) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6218551099300385) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3630237877368927) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4692044109106064) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02705236431211233) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.158935070037842) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43052513897418976) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.14146148413419724) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08752968162298203) { + if (averageDuration_2 <= -0.25115394592285156) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5947653651237488) { + if (averageDuration_2 <= -0.2880716472864151) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02563363965600729) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03612884506583214) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03195782192051411) { + if (maxDuration_2 <= -0.414655476808548) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.31835752725601196) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.26042115688323975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (maxDuration_2 <= -0.3478759527206421) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2857853025197983) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06723587587475777) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7181889414787292) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4624513983726501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.327970415353775) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06209924444556236) { + if (maxDuration_2 <= -0.2608882039785385) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.2533431351184845) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03297067899256945) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4625188708305359) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619706869125366) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.1548214629292488) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7910511195659637) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2022019475698471) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20183028280735016) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.133637934923172) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.28573258221149445) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.17566553503274918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627880573273) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34538060426712036) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33260439336299896) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4939395934343338) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.37209606170654297) { + if (averageDuration_2 <= -0.38668692111968994) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.20557653158903122) { + if (averageDuration_2 <= -0.3239855617284775) { + if (maxDuration_2 <= -0.3913673460483551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8004021048545837) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13283959031105042) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (maxDuration_2 <= -0.097704216837883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.18511583656072617) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (maxDuration_2 <= -0.03207954578101635) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.005164512665942311) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6319258213043213) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.08908027783036232) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.17377524822950363) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101411759853363) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.08880427852272987) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3512573093175888) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.817373812198639) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.15780750662088394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424444913864) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.06957807019352913) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.08057339489459991) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.1149076297879219) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07919298484921455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7810593545436859) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0670135747641325) { + if (averageDuration_2 <= -0.12391439452767372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.31092672049999237) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09241478890180588) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04642844200134277) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24378187954425812) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (maxDuration_2 <= -0.19998186081647873) { + if (averageDuration_2 <= -0.3265655040740967) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4516839385032654) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0880381129682064) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610746502876282) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14972051233053207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (maxDuration_2 <= -0.24571456760168076) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46206933259964) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.3500363379716873) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3620873689651489) { + if (maxDuration_2 <= -0.36422449350357056) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.458945631980896) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3806348592042923) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4457266926765442) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.36545784771442413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5274463593959808) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621739387512207) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.002336133737117052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.016886228695511818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.008951388765126467) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.28224873542785645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618827104568481) { + if (maxDuration_2 <= -0.23088077455759048) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.3530452996492386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4803053140640259) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4383077621459961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.34703555703163147) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.399466797709465) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349805697799) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (maxDuration_2 <= -0.10156898945569992) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.2734299898147583) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.3548585772514343) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5182549059391022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.134098768234253) { + if (numDurations_2 <= -1.2680706679821014) { + if (averageDuration_2 <= -0.25587642192840576) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1105085015296936) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3507310301065445) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (averageDuration_2 <= -0.3638581931591034) { + if (averageDuration_2 <= -0.5945302546024323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04716023989021778) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02442827634513378) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9324439167976379) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6982278227806091) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3393375277519226) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5058281123638153) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35581547021865845) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5944485664367676) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0108682513237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3505582809448242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (averageDuration_2 <= -0.280603364109993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4985969066619873) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2710246294736862) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6765203177928925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940978050232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (maxDuration_2 <= -0.42488741874694824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8922096788883209) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.267133891582489) { + if (averageDuration_2 <= -0.6121794879436493) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13135281950235367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33336856961250305) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31709517538547516) { + if (averageDuration_2 <= -0.22163303196430206) { + if (maxDuration_2 <= -0.7867180407047272) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7523416876792908) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4046890139579773) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17491016536951065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2768465876579285) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.391487717628479) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1921786293387413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0659884661436081) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2735682129859924) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6038977801799774) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3243325352668762) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423399567604065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.23214195668697357) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383228063583374) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5533455610275269) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3310830742120743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5778491795063019) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7945892810821533) { + if (numDurations_2 <= -1.2680706679821014) { + if (averageDuration_2 <= -0.6597628593444824) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5405685305595398) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40377911925315857) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0350375175476074) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5055360049009323) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.169767379760742) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.450542688369751) { + if (maxDuration_2 <= -0.8071745336055756) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.331823706626892) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (averageDuration_2 <= -0.4964972585439682) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.288207232952118) { + if (maxDuration_2 <= -0.6658883094787598) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2658315896987915) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8512656986713409) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4112731069326401) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616687893867493) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4265463203191757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.5636334717273712) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49994249641895294) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30781081318855286) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2867637202143669) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3989070057868958) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6172186732292175) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3836328983306885) { + if (averageDuration_2 <= -0.2099199965596199) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + if (averageDuration_2 <= -0.28552646934986115) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5432513803243637) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9521841108798981) { + if (maxDuration_2 <= -0.5517271757125854) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4325028657913208) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.6057874858379364) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.9133753776550293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4659019261598587) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2323182821273804) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5734217464923859) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.365778848528862) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185136318207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8407496511936188) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326768159866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3523290157318115) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5362549722194672) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4774004966020584) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0461134016513824) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2398325353860855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.4617381989955902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19073880463838577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6593423187732697) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5517847239971161) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5438568294048309) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14034344255924225) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638475418091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5323268175125122) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.583568811416626) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28729744255542755) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6700160503387451) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.043788161128759384) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2972073554992676) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01509860623627901) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4232270121574402) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.608759045600891) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.25021812319755554) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20484384149312973) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (maxDuration_2 <= -0.7431860566139221) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (averageDuration_2 <= -0.7248823642730713) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10391195863485336) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.7160037457942963) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06895928457379341) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9100004732608795) { + if (maxDuration_2 <= -0.607324868440628) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26627956330776215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7185845673084259) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1882456541061401) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.7692575454711914) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18572206795215607) { + if (averageDuration_2 <= -0.694722592830658) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4322318136692047) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6827129423618317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09681638330221176) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.6803655922412872) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.953968048095703) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2221699953079224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6944425702095032) { + if (averageDuration_2 <= -0.6869252324104309) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2934001013636589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3770712018013) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16689516603946686) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35340602695941925) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (maxDuration_2 <= -0.49999450147151947) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2607707679271698) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6999391615390778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (maxDuration_2 <= -0.5999420881271362) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15067999809980392) { + if (averageDuration_2 <= -0.6925711929798126) { + if (maxDuration_2 <= -0.5475203692913055) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9465168714523315) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9320310056209564) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07249876484274864) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07749751955270767) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7552779018878937) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6596881449222565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9412945806980133) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6916144788265228) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6731037795543671) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16803248971700668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6941227912902832) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4576177597045898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3186089396476746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0696258544921875) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (maxDuration_2 <= -0.7031948566436768) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9943352341651917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.667253613471985) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.45206883549690247) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.691427707672119) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17556529492139816) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5531649589538574) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.806822419166565) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7751853168010712) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4978967308998108) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.7180695235729218) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6604251563549042) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3480091989040375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5893377363681793) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8929756581783295) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.6702350974082947) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40980756282806396) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11556170508265495) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2551909387111664) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.674978256225586) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1235536336898804) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6783157289028168) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4847381114959717) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1746509075164795) { + if (averageDuration_2 <= -0.3418702036142349) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3330533653497696) { + if (averageDuration_2 <= -0.4378347396850586) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (averageDuration_2 <= -0.48403574526309967) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1771579012274742) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36549247801303864) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.573576807975769) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3772287368774414) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.48083724081516266) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9386163651943207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (averageDuration_2 <= -0.512138694524765) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3464781194925308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (averageDuration_2 <= -0.4949798285961151) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3792107105255127) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3673401474952698) { + if (averageDuration_2 <= -0.426854208111763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3723486661911011) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.191345691680908) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6237106025218964) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8985591232776642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3074347525835037) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9473568499088287) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3246987760066986) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8645730912685394) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23980845510959625) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6272096931934357) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39591944217681885) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43380169570446014) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6031866371631622) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.46839161217212677) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.47169697284698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07709202542901039) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (averageDuration_2 <= -0.5867889523506165) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5102053880691528) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5986437499523163) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7293791770935059) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6724004149436951) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.633156806230545) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5239104926586151) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10655908659100533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5206049382686615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.43542414903640747) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (maxDuration_2 <= -0.6447048187255859) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4615861773490906) { + if (maxDuration_2 <= -0.4679052531719208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20855501294136047) { + if (maxDuration_2 <= -0.36115720868110657) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07741343975067139) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.622288852930069) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27863624691963196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.129419207572937) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45393383502960205) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7017142474651337) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3231467604637146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17158154398202896) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5518099963665009) { + if (averageDuration_2 <= -0.44130007922649384) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3641948103904724) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23541665077209473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30503928661346436) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05582339130342007) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4187195301055908) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.272508144378662) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9075219631195068) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23875661939382553) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5612537264823914) { + if (maxDuration_2 <= -0.6481466889381409) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.512716144323349) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20340383797883987) { + if (averageDuration_2 <= -0.6282304227352142) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17432929575443268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.347255527973175) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05756162106990814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7457694411277771) { + if (averageDuration_2 <= -0.4230099022388458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5011331886053085) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.005760632222518325) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4341909885406494) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18017614632844925) { + if (averageDuration_2 <= -0.5140837728977203) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239316046238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7363114953041077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.628716230392456) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.4762915074825287) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6027591526508331) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6133553385734558) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7900744080543518) { + if (maxDuration_2 <= -0.3918865770101547) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5133978128433228) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.4174046963453293) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4504803568124771) { + if (averageDuration_2 <= -0.649158388376236) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3595845401287079) { + if (maxDuration_2 <= -0.47594401240348816) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5447709262371063) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5068272948265076) { + if (averageDuration_2 <= -0.444750040769577) { + if (maxDuration_2 <= -0.37288887798786163) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5697040855884552) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (averageDuration_2 <= -0.6175153255462646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.43874116241931915) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.175313949584961) { + if (averageDuration_2 <= -0.4089609980583191) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 1.0085371732711792) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.44852638244628906) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.441428005695343) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.42463284730911255) { + if (maxDuration_2 <= -0.4167777746915817) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.970554769039154) { + if (maxDuration_2 <= -0.566708117723465) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8869194984436035) { + if (averageDuration_2 <= -0.6144526302814484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.669124722480774) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4899631440639496) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6264811456203461) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.45871417224407196) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0938825011253357) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (numDurations_2 <= 1.293113186955452) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.4465599060058594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.7028251886367798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (averageDuration_2 <= -0.5957594811916351) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (averageDuration_2 <= -0.6167005002498627) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1136469841003418) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.505833238363266) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7394025921821594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3166049122810364) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6270146667957306) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (maxDuration_2 <= -0.35865503549575806) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4109825491905212) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4283345937728882) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7422342300415039) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5870160460472107) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47987426817417145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05885088071227074) { + if (averageDuration_2 <= -0.48612749576568604) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11957653984427452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29787254333496094) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24027340859174728) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6375917196273804) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09240681305527687) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5144076347351074) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3177255690097809) { + if (averageDuration_2 <= -0.6097465753555298) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22023065388202667) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17764408141374588) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (averageDuration_2 <= -0.36393165588378906) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45310428738594055) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300742030143738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7317712008953094) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.3801068663597107) { + if (averageDuration_2 <= -0.6358152031898499) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9725026190280914) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3639540523290634) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.649664044380188) { + if (averageDuration_2 <= -0.6521216332912445) { + if (maxDuration_2 <= -0.6609571874141693) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.453486144542694) { + if (maxDuration_2 <= -0.5398513972759247) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1100372076034546) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15560470521450043) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335374176502228) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.39695706963539124) { + if (maxDuration_2 <= -0.5349963009357452) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14793510735034943) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831730857491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.509160190820694) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21411364525556564) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33914391696453094) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5348511636257172) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.002418522723019123) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1252724528312683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40006212890148163) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.185367189347744) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (maxDuration_2 <= -0.36860598623752594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1612241044640541) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.37663717567920685) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19786427170038223) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3586145043373108) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1437944993376732) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.2450234219431877) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5674866437911987) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10678848624229431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842217028141) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17098986357450485) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37748217582702637) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3896859586238861) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5481086671352386) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5220586657524109) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (averageDuration_2 <= -0.3247050493955612) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1016435623168945) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.930047035217285) { + if (averageDuration_2 <= -0.22815407812595367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6816835999488831) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.33297407627105713) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.024240282364189625) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4362252652645111) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0474050045013428) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.4408155679702759) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (averageDuration_2 <= -0.2973327189683914) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4837825298309326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.2628356069326401) { + if (averageDuration_2 <= -0.6116115748882294) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19876184314489365) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (maxDuration_2 <= -0.41573184728622437) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12945043295621872) { + if (maxDuration_2 <= -0.5006453990936279) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (averageDuration_2 <= -0.49204806983470917) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461716651916504) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.04575827158987522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5935895144939423) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354000866413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3703129440546036) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460453018546) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49198848009109497) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4538646638393402) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.009550269693136215) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.33539047837257385) { + if (maxDuration_2 <= -0.4628601521253586) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (maxDuration_2 <= -0.4766075313091278) { + if (maxDuration_2 <= -0.4830254763364792) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1518705040216446) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (averageDuration_2 <= -0.3433626890182495) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (maxDuration_2 <= -0.4050920158624649) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15956388413906097) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4264480769634247) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4033556133508682) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424444913864) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515098571777) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22818587720394135) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.390465646982193) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.3279203027486801) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1279069259762764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (averageDuration_2 <= -0.4124225527048111) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.01179838180542) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5609096884727478) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1058387756347656) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.5328789353370667) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.3991781324148178) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3829228281974792) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9378973245620728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0932992100715637) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6225845217704773) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0303162336349487) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.48643945157527924) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.122105896472931) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.2841893434524536) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5255602300167084) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4567950963974) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.015857099555432796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615945219993591) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1456851959228516) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622765183448792) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6090040504932404) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04053129628300667) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (averageDuration_2 <= -0.5215466320514679) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5704615414142609) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.013742357492447) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.202949285507202) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16084395349025726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5138507783412933) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0862745642662048) { + if (averageDuration_2 <= -0.6358433365821838) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (averageDuration_2 <= -0.5112983882427216) { + if (averageDuration_2 <= -0.5548934638500214) { + if (averageDuration_2 <= -0.6181179583072662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5378026068210602) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.43065008521080017) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.45184531807899475) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2176324725151062) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05154583975672722) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.55894535779953) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4543010890483856) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5723122954368591) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610678553581238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614049196243286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19699878990650177) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618456363677979) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (maxDuration_2 <= -0.5592417418956757) { + if (averageDuration_2 <= -0.4958396553993225) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23776903003454208) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43083733320236206) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4597458839416504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5292026102542877) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6124353408813477) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835479974747) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.45525266230106354) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.377344086766243) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1966893076896667) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619110226631165) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615740180015564) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3015437722206116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9634567499160767) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0755597352981567) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617742896080017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7900325655937195) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8454530239105225) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5649160146713257) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6050421595573425) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.1083666682243347) { + if (maxDuration_2 <= -0.5916727781295776) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1988589763641357) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.5298675298690796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1523914337158203) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6144105568528175) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.4482031911611557) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1578196287155151) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (averageDuration_2 <= -0.392337366938591) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.947862297296524) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617674350738525) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.425231397151947) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03793227206915617) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.47810696065425873) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4139087200164795) { + if (maxDuration_2 <= -0.45589274168014526) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7890188694000244) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0653088167309761) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614469408988953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615974426269531) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615896344184875) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.3064554929733276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4061783403158188) { + if (averageDuration_2 <= -0.37558428943157196) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9716857671737671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.22592103481292725) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (maxDuration_2 <= -0.4199994206428528) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3406248241662979) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4498900175094604) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3772648572921753) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1785793900489807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3633742928504944) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461083471775055) { + if (averageDuration_2 <= -0.5000107735395432) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4555639624595642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4182137995958328) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461818277835846) { + if (averageDuration_2 <= -0.3874751329421997) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8219747841358185) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09628749452531338) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2558033913373947) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.4240894019603729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617498517036438) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.5005238791927695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.4107474386692047) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3721015453338623) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5349827706813812) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.47839054465293884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.6088183522224426) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7177000939846039) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.35093338787555695) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2844176292419434) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.39208416640758514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8987681567668915) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.3000231236219406) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2012681365013123) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (maxDuration_2 <= -0.4180871546268463) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.44734987616539) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4093968272209167) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (averageDuration_2 <= -0.27266135811805725) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1599007844924927) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4885703772306442) { + if (averageDuration_2 <= -0.29641111195087433) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.035209111170843244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4422590136528015) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3051094561815262) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4507312774658203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.23984725028276443) { + if (maxDuration_2 <= -0.4499964565038681) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4872463494539261) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617215394973755) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615954756736755) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615554213523865) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4545214176177979) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3095976561307907) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4473835229873657) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (averageDuration_2 <= -0.28475847840309143) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9446793794631958) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.448905110359192) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.4052489250898361) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.25084976851940155) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6028887629508972) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.09518700838089) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8930988311767578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8228538036346436) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381955832242966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (averageDuration_2 <= 0.018134440295398235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3194934129714966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3533165752887726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.517324686050415) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3224862813949585) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2944737672805786) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2214270234107971) { + if (averageDuration_2 <= 0.1397598832845688) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.296149730682373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2659074664115906) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7107703685760498) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6790503561496735) { + if (maxDuration_2 <= -0.25680792331695557) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.07440219447016716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2526112049818039) { + if (averageDuration_2 <= -0.05853019282221794) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6469157338142395) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.148527979850769) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6219379305839539) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7134260833263397) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1255253180861473) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.0805900394916534) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4614522159099579) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4630298614501953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (averageDuration_2 <= -0.2724656015634537) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.450217366218567) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.17435260117053986) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13100546598434448) { + if (averageDuration_2 <= -0.43089108169078827) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5109862238168716) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22038308531045914) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2274562492966652) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1104446053504944) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21713721007108688) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8789362609386444) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7861332893371582) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9653382301330566) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23011482506990433) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08210491389036179) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3861694931983948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + if (maxDuration_2 <= -0.22111208736896515) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3339366316795349) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.12110622972249985) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5054148137569427) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.6049301624298096) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.053722286596894264) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.030183885246515274) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (maxDuration_2 <= -0.0834856890141964) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.741899698972702) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (averageDuration_2 <= -0.5247022211551666) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40397731959819794) { + if (averageDuration_2 <= -0.6370089948177338) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0319364666938782) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9912260174751282) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24124965071678162) { + if (maxDuration_2 <= -0.039269763976335526) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5116555094718933) { + if (averageDuration_2 <= -0.5341428816318512) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2933339923620224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.325233593583107) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7595236897468567) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (averageDuration_2 <= -0.2447378933429718) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.272434338927269) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23568308353424072) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09926561452448368) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.22893311083316803) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345905259251595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4966981112957001) { + if (maxDuration_2 <= -0.28517140448093414) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.2649085074663162) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12636230140924454) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1391429752111435) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4735252261161804) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3962622284889221) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (averageDuration_2 <= -0.20003663003444672) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17955081909894943) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.23426517099142075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32659387588500977) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39409829676151276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.11538991704583168) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15699292719364166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2616274952888489) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23410074412822723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.19660581648349762) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3399337828159332) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6022156476974487) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13361117616295815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28817401826381683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.398678258061409) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.21613691002130508) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.37633463740348816) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.21888645738363266) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.15703501552343369) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0619677305221558) { + if (maxDuration_2 <= -0.19411609321832657) { + if (averageDuration_2 <= -0.32283158600330353) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (maxDuration_2 <= -0.31465210020542145) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7165998220443726) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17296283692121506) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0705103874206543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4290362745523453) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07478025183081627) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9115525186061859) { + if (maxDuration_2 <= -0.25204138457775116) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6517910659313202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40493257343769073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1730526089668274) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533584326505661) { + if (maxDuration_2 <= -0.30819128453731537) { + if (maxDuration_2 <= -0.31663520634174347) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14689862728118896) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.2253367006778717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36239226162433624) { + if (maxDuration_2 <= -0.2880309522151947) { + if (averageDuration_2 <= -0.33100661635398865) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (averageDuration_2 <= -0.34384599328041077) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35519394278526306) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461520254611969) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612388610839844) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.34608781337738037) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4484865516424179) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (maxDuration_2 <= -0.2596343457698822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.880715936422348) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01621931977570057) { + if (averageDuration_2 <= -0.5576055645942688) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0279210209846497) { + if (maxDuration_2 <= -0.3417240381240845) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.24201448261737823) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27366068959236145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + if (averageDuration_2 <= -0.4112266004085541) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2208606600761414) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7950571775436401) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { + if (averageDuration_2 <= -0.330180361866951) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.272406741976738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3633762449026108) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.20011864602565765) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.222715735435486) { + if (maxDuration_2 <= -0.3232835829257965) { + if (maxDuration_2 <= -0.33270250260829926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8881430327892303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619784951210022) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6649061441421509) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (maxDuration_2 <= -0.30399955809116364) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.955045759677887) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4113122522830963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32344405353069305) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1340287327766418) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8434671759605408) { + if (maxDuration_2 <= -0.34620437026023865) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0360899567604065) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8849446773529053) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.44634944200515747) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.49420349299907684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3940853029489517) { + if (averageDuration_2 <= -0.25718414783477783) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5491228699684143) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5274609625339508) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3197579085826874) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.033405440859496593) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14118413627147675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.28058217465877533) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.28234250843524933) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (maxDuration_2 <= -0.32595036923885345) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.28076185286045074) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03482109773904085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20322178304195404) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.41251610219478607) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.3314919173717499) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5054936110973358) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087389945984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2226475179195404) { + if (averageDuration_2 <= -0.26614169776439667) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.2798497676849365) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (averageDuration_2 <= -0.2695035934448242) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2607783079147339) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7267124354839325) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608479738235474) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2075033113360405) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.2662852853536606) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (maxDuration_2 <= -0.22071188688278198) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332335531711578) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.22192628681659698) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2761172503232956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27592048048973083) { + if (maxDuration_2 <= -0.23805337399244308) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.22337881475687027) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618201851844788) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.23688071966171265) { + if (maxDuration_2 <= -0.3253728449344635) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9149197340011597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2059846669435501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.546418309211731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.3281007409095764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (averageDuration_2 <= -0.21085462719202042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616687297821045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36268191039562225) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6742686331272125) { + if (averageDuration_2 <= -0.20897146314382553) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9773394763469696) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.053654758259654045) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5199229717254639) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.043676257133484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6200047135353088) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513206481933594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.33706134557724) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7641547620296478) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (maxDuration_2 <= -0.28351520001888275) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (averageDuration_2 <= -0.3108229786157608) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (maxDuration_2 <= -0.28711916506290436) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.23212911933660507) { + if (maxDuration_2 <= -0.2653885930776596) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0769655853509903) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.142924666404724) { + if (maxDuration_2 <= -0.33834294974803925) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.850790411233902) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3424205332994461) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9533257186412811) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5376587510108948) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.19444938749074936) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5190798342227936) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.24758196622133255) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2643298953771591) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (maxDuration_2 <= -0.3120182156562805) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6790743172168732) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0015177130699158) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611186385154724) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2825992107391357) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3006844520568848) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.2966272830963135) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5039710998535156) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6772676110267639) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.056516630575060844) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38820597529411316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.121818721294403) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.24461983144283295) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4976775497198105) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (averageDuration_2 <= -0.5690076947212219) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.12697963416576385) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9125380516052246) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01814319472759962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4284423440694809) { + if (maxDuration_2 <= -0.17209433764219284) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.48471736907959) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.088798999786377) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.22159480303525925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2929857075214386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7443138360977173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6040880978107452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.2751609832048416) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.27451182901859283) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.543830007314682) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8745182156562805) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04753599129617214) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4170562028884888) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.0378661155700684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424482166767) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16009339690208435) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612905979156494) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3180261254310608) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02247861074283719) { + if (averageDuration_2 <= -0.4724709689617157) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2534714937210083) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09222996234893799) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.719666987657547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5401298105716705) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.31061840057373047) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29809047281742096) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09862838312983513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6495670080184937) { + if (maxDuration_2 <= -0.16719868779182434) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5304866433143616) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (averageDuration_2 <= -0.18548375368118286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.29344412684440613) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5134530961513519) { + if (averageDuration_2 <= -0.5381163656711578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.4759577661752701) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.17640001326799393) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4658149480819702) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17726998776197433) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1743083968758583) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.03256593085825443) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.17875602096319199) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613726735115051) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (averageDuration_2 <= -0.6234489381313324) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.12524712830781937) { + if (averageDuration_2 <= -0.24189632385969162) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16471368074417114) { + if (maxDuration_2 <= -0.15773403644561768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.541467308998108) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3762378543615341) { + if (averageDuration_2 <= -0.3766048103570938) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.853185385465622) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13502199947834015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.212310314178467) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111741781235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4931783229112625) { + if (averageDuration_2 <= -0.5068649351596832) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1672489643096924) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.1817498877644539) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (averageDuration_2 <= -0.2322753593325615) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33120138943195343) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35249628126621246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4632027745246887) { + if (maxDuration_2 <= -0.1661374866962433) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4443861246109009) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5568251311779022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.47463560104370117) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620898962020874) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.47202688455581665) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37259049713611603) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09167009592056274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5391761660575867) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2889665365219116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (averageDuration_2 <= -0.24759628623723984) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8785081505775452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3675816059112549) { + if (averageDuration_2 <= -0.35455358028411865) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.093022644519806) { + if (averageDuration_2 <= -0.5506995320320129) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8984744846820831) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1747518852353096) { + if (maxDuration_2 <= -0.19668171554803848) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06866029649972916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.28351762890815735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5958105623722076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4743887931108475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5529657304286957) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.014614461921155453) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3099656403064728) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5808907449245453) { + if (averageDuration_2 <= -0.6117734014987946) { + if (averageDuration_2 <= -0.6993576884269714) { + if (maxDuration_2 <= -0.25316329300403595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3025229573249817) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2574550360441208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4908469915390015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2325873300433159) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0039320229552686214) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (maxDuration_2 <= -0.1874096915125847) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.306581974029541) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5163620114326477) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736663818359375) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6376422047615051) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.274852991104126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4451114982366562) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (maxDuration_2 <= -0.2820182889699936) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.345740869641304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + if (maxDuration_2 <= -0.06974821165204048) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2684081345796585) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.967336505651474) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4778141975402832) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.772266983985901) { + if (maxDuration_2 <= -0.16478516906499863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4619466662406921) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5324616432189941) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4415391683578491) { + if (averageDuration_2 <= -0.297176256775856) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.18925846368074417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1222290992736816) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5334058403968811) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20583121478557587) { + if (maxDuration_2 <= -0.1401723548769951) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654292166233063) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0100053548812866) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + if (maxDuration_2 <= -0.22920402884483337) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7036527991294861) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.0163023471832275) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462061583995819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4813380241394043) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4178837537765503) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8595393002033234) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (maxDuration_2 <= -0.34348413348197937) { + if (averageDuration_2 <= -0.2924409359693527) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.2427998036146164) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.1787833273410797) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (maxDuration_2 <= -0.33751721680164337) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10897934809327126) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (averageDuration_2 <= -0.3148110955953598) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277872279286385) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091154009103775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (averageDuration_2 <= -0.22320546209812164) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.410847783088684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.044591041281819344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612124562263489) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1888128519058228) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (maxDuration_2 <= -0.21882259100675583) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8042240738868713) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (averageDuration_2 <= -0.2645341157913208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4498792886734009) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4774925112724304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.207729160785675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.459603190422058) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5215785503387451) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4251258969306946) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.009034345857799053) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18255729973316193) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.13578222692012787) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.268459975719452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.06169711425900459) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8548007607460022) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.12043766677379608) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4913126528263092) { + if (maxDuration_2 <= -0.09624028950929642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.19914613664150238) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.43678878247737885) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2505628392100334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.2378152534365654) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19619394838809967) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.030472377315163612) { + if (averageDuration_2 <= -0.10769497975707054) { + if (averageDuration_2 <= -0.15477293729782104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205805659294128) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8365260660648346) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2954769432544708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13605600595474243) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26047688722610474) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.07508211582899094) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1505725085735321) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.07319875061511993) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060375809669495) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.539885550737381) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5493299961090088) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.065772533416748) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05668957531452179) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.19351089000701904) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.04092031344771385) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7622863054275513) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03905022796243429) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8175609409809113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.28748664259910583) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.28893762826919556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.98470401763916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.1686907336115837) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3510195314884186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.757363885641098) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.977627694606781) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.07460862025618553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -3.011645793914795) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.542745441198349) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04202357120811939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.07433109730482101) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (maxDuration_2 <= -0.16729485988616943) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.818825900554657) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623234272003174) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.402473509311676) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184681713581) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1811463236808777) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3268954753875732) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (maxDuration_2 <= -0.16798125207424164) { + if (averageDuration_2 <= -0.1315850242972374) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3713851571083069) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.03894988261163235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7361017763614655) { + if (averageDuration_2 <= -0.17046784609556198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.18244300782680511) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.05030343495309353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2315274253487587) { + if (maxDuration_2 <= -0.15809118747711182) { + if (maxDuration_2 <= -0.23226862400770187) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.37348559498786926) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1456851959228516) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.13557962328195572) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (maxDuration_2 <= -0.14387769252061844) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5494690537452698) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.04377059452235699) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0795602202415466) { + if (maxDuration_2 <= -0.25501224398612976) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7096761763095856) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.627981036901474) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7725633382797241) { + if (averageDuration_2 <= -0.17408805340528488) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8901151120662689) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3738009035587311) { + if (maxDuration_2 <= -0.24569443613290787) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2276285886764526) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.115374207496643) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4109545946121216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.26836518943309784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07532546296715736) { + if (averageDuration_2 <= -0.607037365436554) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19844172149896622) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7980000674724579) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.7264435887336731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (maxDuration_2 <= -0.6447985768318176) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2788488268852234) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0245378017425537) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (averageDuration_2 <= -0.6758981049060822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7658474445343018) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8233934342861176) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11207352578639984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17862650007009506) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.2158416286110878) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.628980278968811) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1355701982975006) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6467078328132629) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (maxDuration_2 <= -0.5214564800262451) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (averageDuration_2 <= -0.6196662187576294) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1915777176618576) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7090363204479218) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6380235552787781) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6714982688426971) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21390405297279358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8822689652442932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07629472762346268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2010788694024086) { + if (maxDuration_2 <= -0.1464180126786232) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22721769660711288) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29343073070049286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (averageDuration_2 <= -0.7000639140605927) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26463837921619415) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.894895315170288) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (averageDuration_2 <= -0.6375980973243713) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.1250547133386135) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.6928893625736237) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.265079602599144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2201671451330185) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.661405622959137) { + if (averageDuration_2 <= -0.6678074598312378) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.770825207233429) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12565887719392776) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.23575107753276825) { + if (averageDuration_2 <= -0.6474745571613312) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.8568262457847595) { + if (maxDuration_2 <= -0.6288401484489441) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1515476480126381) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6612808704376221) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5098477602005005) { + if (maxDuration_2 <= -0.5653150379657745) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2731640934944153) { + if (averageDuration_2 <= -0.5767695605754852) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0408272743225098) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2496701404452324) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0279672145843506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9882237315177917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6474882364273071) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (averageDuration_2 <= -0.5276211798191071) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5689947605133057) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13950705528259277) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (maxDuration_2 <= -0.09024034067988396) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5726988911628723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (maxDuration_2 <= -0.5182474851608276) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36447541415691376) { + if (maxDuration_2 <= -0.47984445095062256) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307503938674927) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (maxDuration_2 <= -0.3436690866947174) { + if (averageDuration_2 <= -0.4704529792070389) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9289629459381104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4901038408279419) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (averageDuration_2 <= -0.4266274869441986) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39644569158554077) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.02020001411438) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (maxDuration_2 <= -0.2175765186548233) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37602217495441437) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.4268293082714081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7919865548610687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.436114177107811) { + if (maxDuration_2 <= -0.3326621353626251) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2471717968583107) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19543035328388214) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2873567044734955) { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.39691442251205444) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11726292595267296) { + if (averageDuration_2 <= -0.6328580677509308) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02542587649077177) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.945031225681305) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (numDurations_2 <= 2.715993046760559) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8881857991218567) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02816903404891491) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2025655061006546) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (maxDuration_2 <= -0.27628423273563385) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9758899211883545) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08445678278803825) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0655585490167141) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8854756653308868) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411147415638) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { + if (averageDuration_2 <= -0.46087510883808136) { + if (maxDuration_2 <= -0.6129247546195984) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (averageDuration_2 <= -0.6105188429355621) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (maxDuration_2 <= -0.6118102371692657) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (averageDuration_2 <= -0.5724523961544037) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7005680203437805) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1562942266464233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3348832726478577) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3536808490753174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.2928657680749893) { + if (maxDuration_2 <= -0.7248163819313049) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43810851871967316) { + if (averageDuration_2 <= -0.6376657485961914) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08563710004091263) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5500378012657166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.81649512052536) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (averageDuration_2 <= -0.557155430316925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9711636304855347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.688724160194397) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22516443580389023) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4820135682821274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.0827866643667221) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.313352346420288) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11326995864510536) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8234044313430786) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.847002923488617) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.319106325507164) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.3011098653078079) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2666581869125366) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23562312126159668) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.129824660718441) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.525141566991806) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2591913193464279) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (averageDuration_2 <= -0.2899358421564102) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620584785938263) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20512349903583527) { + if (maxDuration_2 <= -0.33825160562992096) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9364436864852905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.452235609292984) { + if (averageDuration_2 <= -0.5695056617259979) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4804098457098007) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4478062689304352) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6641151905059814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.016020972281694412) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.5970219075679779) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2503814622759819) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9198275804519653) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2582220286130905) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460453018546) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4424658641219139) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (maxDuration_2 <= -0.7163598835468292) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8571887016296387) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5509451329708099) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1881877183914185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0094910860061646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.4033753871917725) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5331827402114868) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7573455572128296) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.350558340549469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9150264263153076) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3819319605827332) { + if (averageDuration_2 <= -0.40911445021629333) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2133159041404724) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7019365727901459) { + if (averageDuration_2 <= -0.5991204679012299) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2536173462867737) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6588824391365051) { + if (averageDuration_2 <= -0.5385065674781799) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32132817804813385) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6033362746238708) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7181000113487244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.590578556060791) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (maxDuration_2 <= -0.6715058386325836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.061080813407898) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5882075130939484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.1049726009368896) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.5445163249969482) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.46005986630916595) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9543364346027374) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.05251327343285084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8226003646850586) { + if (maxDuration_2 <= -0.5809164941310883) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48570142686367035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1526985615491867) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6657903790473938) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.16826745122671127) { + if (maxDuration_2 <= -0.5010175406932831) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7894352376461029) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.358297884464264) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6414737403392792) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8942911028862) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.407070055603981) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2788926362991333) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6951417922973633) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101411759853363) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.38957931101322174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.334647297859192) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3383114337921143) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.590038001537323) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7766198515892029) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6916195452213287) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1320453882217407) { + if (averageDuration_2 <= -0.2782624065876007) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.628485083580017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.29119522869586945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.01113498210907) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3315422981977463) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6516931354999542) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7188244760036469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.545235812664032) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8401204347610474) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.44763000309467316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3216712921857834) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.034652352333069) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461464524269104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8922342658042908) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= -0.5868657529354095) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239316046238) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.42392972111701965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615544080734253) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614967703819275) { + if (averageDuration_2 <= -0.5306451916694641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1982994377613068) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (maxDuration_2 <= -0.5801111161708832) { + if (averageDuration_2 <= -0.6906363070011139) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33930803835392) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618114233016968) { + if (averageDuration_2 <= -0.284215971827507) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617030024528503) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (averageDuration_2 <= -0.632073312997818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.08030135557055473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.779565453529358) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4447349309921265) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.34639835357666) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0140175819396973) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + if (maxDuration_2 <= -0.6343664228916168) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23838981986045837) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.5228671729564667) { + if (averageDuration_2 <= -0.3877088129520416) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3590235412120819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618280529975891) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.5593884289264679) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.188903570175171) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.18310410529375076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5787403583526611) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0260339975357056) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9766682386398315) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3071071654558182) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5771068334579468) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5930547714233398) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9712387919425964) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6301410794258118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.6343664824962616) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9844173192977905) { + if (maxDuration_2 <= -0.18542402237653732) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8636749386787415) { + if (maxDuration_2 <= -0.5203977823257446) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6387429684400558) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2443223595619202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28608767688274384) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5533960461616516) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9936091303825378) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.056148648262024) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.4271390736103058) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5774387121200562) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.2505267709493637) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.4064226150512695) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610571265220642) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5304918587207794) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.5153095424175262) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (numDurations_2 <= 1.2931131720542908) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36976155638694763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.113007068634033) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.5206721425056458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3099476099014282) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.919241189956665) { + if (maxDuration_2 <= -0.3174380362033844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5713846385478973) { + if (maxDuration_2 <= -0.45502664148807526) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7936633825302124) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337136715650558) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.6088816523551941) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (maxDuration_2 <= -0.38161639869213104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4712699353694916) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6380131840705872) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3151870518922806) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8180266320705414) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33012063801288605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4257570058107376) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.679832100868225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758370161057) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.794986069202423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.668535977602005) { + if (averageDuration_2 <= -0.4468124955892563) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6344201862812042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.43319031596183777) { + if (averageDuration_2 <= -0.5056062042713165) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990091323853) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7450112402439117) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0832464694976807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.796681821346283) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6176962852478027) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.654976725578308) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.011162791401147842) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7893766164779663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= -0.44604550302028656) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3743445873260498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0739621818065643) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3023143857717514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6267630457878113) { + if (averageDuration_2 <= -0.4564829170703888) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5411526560783386) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5697179436683655) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619218707084656) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4639639258384705) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.30472269654273987) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3473442792892456) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.31854650378227234) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7960012555122375) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.700783371925354) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.39081817865371704) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.16811807453632355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48550011217594147) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5503170490264893) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1315871477127075) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5816194415092468) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8439178466796875) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.816646009683609) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (maxDuration_2 <= -0.18679672479629517) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11588183045387268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6142922937870026) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617440104484558) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3066533207893372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3369972705841064) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (maxDuration_2 <= -0.406484991312027) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0016361474990845) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47940488159656525) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.453476905822754) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6696322858333588) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.061045942828059196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06579532101750374) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611685276031494) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5426492094993591) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.38106584548950195) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3868193030357361) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3313126415014267) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612310528755188) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.418724000453949) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6883209347724915) { + if (numDurations_2 <= 6.700057029724121) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2680702209472656) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9130818843841553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0926077365875244) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2703052759170532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5975099205970764) { + if (averageDuration_2 <= -0.5132721364498138) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3550577312707901) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.44848693907260895) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618417024612427) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.501266896724701) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.080111026763916) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.185534358024597) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (maxDuration_2 <= -0.512303352355957) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9317080974578857) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.699253499507904) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4540174603462219) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6765041947364807) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6355568766593933) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.47871604561805725) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.443142294883728) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07867522723972797) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6881247162818909) { + if (averageDuration_2 <= -0.6056359112262726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21801240742206573) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6837410926818848) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6835466623306274) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615778923034668) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461376667022705) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2004525363445282) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.256256103515625) { + if (numDurations_2 <= -0.6989187151193619) { + if (averageDuration_2 <= -0.5324789583683014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.048086049035191536) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8483448028564453) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6431209444999695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.1273745819926262) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7373865842819214) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5087015628814697) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.2841893434524536) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.6281538009643555) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.5853307247161865) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622921347618103) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5486994981765747) { + if (maxDuration_2 <= -0.1698252335190773) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1251400709152222) { + if (maxDuration_2 <= -0.6437981426715851) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37816889584064484) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.5885316133499146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4551496505737305) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613531827926636) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.9393047094345093) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.050012111663818) { + if (maxDuration_2 <= -0.15419330447912216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2935070395469666) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (averageDuration_2 <= -0.6678782105445862) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8927212059497833) { + if (averageDuration_2 <= -0.4939402639865875) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795464992523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (averageDuration_2 <= -0.3147253841161728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006180226802826) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8186551034450531) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.800664186477661) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.27993708848953247) { + if (averageDuration_2 <= -0.4538297951221466) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.39163969457149506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8394768834114075) { + if (averageDuration_2 <= -0.40059448778629303) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1036253571510315) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9819967150688171) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (maxDuration_2 <= -0.5427032113075256) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611616730690002) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.098084568977356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014206530526280403) { + if (averageDuration_2 <= -0.636952668428421) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (averageDuration_2 <= -0.6880501508712769) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9303662180900574) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2914080023765564) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.6869477033615112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (maxDuration_2 <= -0.23257765173912048) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8981298208236694) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.12558414041996002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5738900005817413) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.5338109135627747) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15049386769533157) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6172495484352112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.042088031768799) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.156949996948242) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.6048632264137268) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5296398103237152) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.016195381991565228) { + if (averageDuration_2 <= -0.629343569278717) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5984353125095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8143409490585327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (averageDuration_2 <= -0.5418438613414764) { + if (maxDuration_2 <= -0.6308180093765259) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (maxDuration_2 <= -0.5308350324630737) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.013676952105015516) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6202227473258972) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.003230966569390148) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (averageDuration_2 <= -0.6046774983406067) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5792258977890015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= -0.22390571236610413) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7296390533447266) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8247008323669434) { + if (maxDuration_2 <= -0.19773801416158676) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7399566471576691) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.3262604475021362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.056736469268799) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39914655685424805) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4056227505207062) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8089635968208313) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.21955451369285583) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.476896196603775) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768865585327) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.010589920450001955) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8097683191299438) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5087048709392548) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615349173545837) { + if (numDurations_2 <= 2.7159931659698486) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.923100084066391) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34144285321235657) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.21123460680246353) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9690228700637817) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621230959892273) { + if (averageDuration_2 <= -0.5072685480117798) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616071581840515) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223794698715) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5266422033309937) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.31560930609703064) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1402511596679688) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22836538031697273) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6124423146247864) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4246256351470947) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2010539546608925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= -0.41373856365680695) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6398673951625824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.485487461090088) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4561148136854172) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9764195084571838) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.509722590446472) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22281455248594284) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841111093759537) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (maxDuration_2 <= -0.3898122310638428) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.9304614961147308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8798241019248962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461768388748169) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.011978268623352) { + if (maxDuration_2 <= -0.08942480012774467) { + if (averageDuration_2 <= -0.6878019571304321) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9181130826473236) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.627740889787674) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40961697697639465) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.579987049102783) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11338623613119125) { + if (averageDuration_2 <= -0.6459107995033264) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9609633684158325) { + if (averageDuration_2 <= -0.7186458706855774) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11055562645196915) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.058868955820798874) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (maxDuration_2 <= -0.200521320104599) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4291780591011047) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.821343332529068) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (maxDuration_2 <= -0.2986934781074524) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08906470239162445) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04916457645595074) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.3108910322189331) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2250828742980957) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (maxDuration_2 <= -0.666797548532486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9498692154884338) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (maxDuration_2 <= -0.25966985523700714) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (averageDuration_2 <= -0.6235432624816895) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (averageDuration_2 <= -0.6224396526813507) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6378272473812103) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.586611270904541) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.5609686970710754) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (maxDuration_2 <= -0.519057959318161) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5966320633888245) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8679518103599548) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21357513964176178) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (averageDuration_2 <= -0.6323291659355164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45117759704589844) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.970554769039154) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (averageDuration_2 <= -0.6181385219097137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8014824390411377) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 4.4234490394592285) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606603980064392) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4001330733299255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6647417843341827) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0172709226608276) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22630078345537186) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7240342497825623) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47814084589481354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17883510142564774) { + if (averageDuration_2 <= -0.6729955971240997) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.916710078716278) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.6335899829864502) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.3168049305677414) { + if (maxDuration_2 <= -0.4159294664859772) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.16312622278928757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11933080106973648) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.18245819956064224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.683826923370361) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8347786962985992) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (maxDuration_2 <= -0.05908569507300854) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8488622307777405) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6972857117652893) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.4592611491680145) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3287367224693298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4507088661193848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.3886016607284546) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (maxDuration_2 <= -0.4541349709033966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5545796155929565) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7296634316444397) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4849693775177002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616491794586182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7787335515022278) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= -0.7061682045459747) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5987449586391449) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615055918693542) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.026282787322998) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4582929611206055) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9287554323673248) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16862349212169647) { + if (averageDuration_2 <= -0.6625210046768188) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.6447226405143738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9334983229637146) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8466048836708069) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32499878108501434) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251907348633) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26058579981327057) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27069348096847534) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.28479087352752686) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.8504594564437866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4600653648376465) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4986836612224579) { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614420533180237) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.9961256682872772) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5636332631111145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= -0.472507119178772) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5545671880245209) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.883689045906067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5994730889797211) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1803824305534363) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5243768095970154) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.019699811935425) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6389344036579132) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21253760159015656) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.992276519536972) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32333701848983765) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.442237973213196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.456537127494812) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8416776061058044) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7805819511413574) { + if (averageDuration_2 <= -0.5799857378005981) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.854166328907013) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7287027537822723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.38945066928863525) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9627065658569336) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9730144739151) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13339687138795853) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8525102138519287) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0389721393585205) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.273147813975811) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.1345902755856514) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.149449348449707) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0108682513237) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.38592463731765747) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608294367790222) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.2620986998081207) { + if (maxDuration_2 <= -0.4741002023220062) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6373211145401) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5783068239688873) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { + if (maxDuration_2 <= -0.34009797871112823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4366424083709717) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.35893110930919647) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4009338766336441) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17016811668872833) { + if (averageDuration_2 <= -0.533677339553833) { + if (numDurations_2 <= 4.4234490394592285) { + if (maxDuration_2 <= -0.05760914273560047) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.872537910938263) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (averageDuration_2 <= -0.5382843613624573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (averageDuration_2 <= -0.5016792118549347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575631141663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7664079666137695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.56096875295043) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4395319819450378) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.199471950531006) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6617713570594788) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.273901879787445) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2975906580686569) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6513705253601074) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7990553379058838) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2215687707066536) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0975579917430878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.252526044845581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842179775238) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13034740090370178) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1119801998138428) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09155382215976715) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9698109030723572) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3970448225736618) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10875974968075752) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1916980743408203) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10908609256148338) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24885770678520203) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904514193535) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.0005691051483154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.432640314102173) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.266158938407898) { + if (maxDuration_2 <= -0.17317841202020645) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2411949038505554) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.14644820988178253) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0716551542282104) { + if (maxDuration_2 <= -0.2712797522544861) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8212940692901611) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5331338942050934) { + if (averageDuration_2 <= -0.22687120735645294) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.367729514837265) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5334058552980423) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7650062441825867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.887032389640808) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.2588758319616318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7659831643104553) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= -0.2124149352312088) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0864598751068115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6947140097618103) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.15018897503614426) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.218908429145813) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + if (averageDuration_2 <= -0.17097879201173782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.143068313598633) { + if (averageDuration_2 <= 0.1063140258193016) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5306227803230286) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.14319629222154617) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.108508586883545) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4743780344724655) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5472859442234039) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5438525080680847) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7892730832099915) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5100665390491486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.06111019663512707) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4293491989374161) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6700903177261353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (maxDuration_2 <= -0.031324757263064384) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16305415332317352) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6757018864154816) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9380845427513123) { + if (averageDuration_2 <= -0.2033289298415184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.691187381744385) { + if (maxDuration_2 <= -0.3383149206638336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8759901523590088) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18265940994024277) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.521420031785965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1772414892911911) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28894054889678955) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.010329468408599496) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0752306766808033) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.142195701599121) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31678687036037445) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.163061738014221) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8190291225910187) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5628749132156372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4434279799461365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.126781165599823) { + if (maxDuration_2 <= -0.20854999125003815) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.40810826420783997) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615368843078613) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 1.2931131720542908) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.146690845489502) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8579038381576538) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.29245805740356445) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= -0.17671193182468414) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665165930986404) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622784852981567) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (averageDuration_2 <= -0.16056165099143982) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.24346733838319778) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617801308631897) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8407304286956787) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.42058065533638) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09056577831506729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3208264410495758) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461520254611969) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.007359815528616309) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (averageDuration_2 <= -0.20514479279518127) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.13425371795892715) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617342352867126) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9708797335624695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4633405804634094) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (numDurations_2 <= 2.1468411684036255) { + if (maxDuration_2 <= -0.1738419383764267) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29960088431835175) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.17539717257022858) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.08158387616276741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9616619348526) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6133179664611816) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (averageDuration_2 <= -0.08819058537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8585195541381836) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620859622955322) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.391000747680664) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3642842769622803) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.769197106361389) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (averageDuration_2 <= 1.127707600593567) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.232879102230072) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.021375520154833794) { + if (maxDuration_2 <= 0.44858473539352417) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7460405826568604) { + if (maxDuration_2 <= 0.22034376114606857) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (averageDuration_2 <= -0.2703048884868622) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484130263328552) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3583451211452484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.977935403585434) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335149466991425) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5719137787818909) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4494861662387848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12650687247514725) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9711636304855347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.03794736601412296) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5897117853164673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= -0.026710317470133305) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.11218501627445221) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19032950699329376) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4957520067691803) { + if (averageDuration_2 <= 0.11692098155617714) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.771731048822403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.0927669070661068) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.42751912772655487) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9479746520519257) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (averageDuration_2 <= 0.09008290246129036) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.12046515569090843) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184718966484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8858786523342133) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34036800265312195) { + if (averageDuration_2 <= -0.11376642435789108) { + if (maxDuration_2 <= -0.01850185263901949) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.681984543800354) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (averageDuration_2 <= -0.5759931206703186) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.13441523537039757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5196825265884399) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (averageDuration_2 <= -0.4052688777446747) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485253512859344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485326826572418) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.43701186776161194) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3160262405872345) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485814094543457) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118889793754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (averageDuration_2 <= 0.5439204275608063) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { + if (averageDuration_2 <= -0.18931268155574799) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6789072453975677) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.023485160432755947) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + if (averageDuration_2 <= -0.15606769174337387) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.275984451174736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40794865787029266) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4511452615261078) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291398823261261) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.30773666501045227) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.15591146796941757) { + if (averageDuration_2 <= -0.38356249034404755) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (maxDuration_2 <= 0.09950897097587585) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12833990901708603) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044531345367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (averageDuration_2 <= -0.05590721219778061) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335745513439178) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481330335140228) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5256181955337524) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2759339064359665) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.07600072771310806) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7501570582389832) { + if (maxDuration_2 <= 0.323102667927742) { + if (averageDuration_2 <= -0.2706994265317917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718024134635925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9268515706062317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5267339944839478) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.6609642505645752) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.48651473224163055) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483929693698883) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2898607701063156) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.260788157582283) { + if (maxDuration_2 <= 0.23940204083919525) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838244438171) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7470153272151947) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (averageDuration_2 <= -0.0016553624300286174) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30284979939460754) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744438707828522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9224752485752106) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.10446617007255554) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11939822137355804) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591094017029) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48712749779224396) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.27817265689373016) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3664710074663162) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.718052476644516) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0057842135429382) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7259543836116791) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7144536375999451) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21182775497436523) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46677136421203613) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31427889317274094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4337436258792877) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3205748349428177) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5155184268951416) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.4456382989883423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.2079158052802086) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30120691657066345) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8961704969406128) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.045531051233410835) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (maxDuration_2 <= 0.11807874217629433) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23435544967651367) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6666222810745239) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.13358815014362335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5863189101219177) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5283451676368713) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0582075715065002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.12900003045797348) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4236430376768112) { + if (maxDuration_2 <= -0.0222046272829175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1400299370288849) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6142241358757019) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9905251264572144) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606166541576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.012466492597013712) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537497401237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.066078007221222) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5662574768066406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.008512758184224367) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5653239488601685) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.16253018379211426) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43927276134490967) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (averageDuration_2 <= -0.10979708656668663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.18707860261201859) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8514364659786224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45450422167778015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7091420590877533) { + if (averageDuration_2 <= -0.2383028119802475) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4316047728061676) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7992309927940369) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.12550751864910126) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (maxDuration_2 <= -0.013213643804192543) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19446878880262375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178307533264) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8922097086906433) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.11133947968482971) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5851742923259735) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (averageDuration_2 <= 0.3801325857639313) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + if (averageDuration_2 <= -0.07871228829026222) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6752995252609253) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.2595261335372925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.24505255371332169) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5330264270305634) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9725194573402405) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3482784330844879) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (averageDuration_2 <= -0.07768546044826508) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.17088397592306137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8279767632484436) { + if (averageDuration_2 <= -0.13079051673412323) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39584796130657196) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.906103253364563) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118843227625) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41164593398571014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5393894612789154) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7148667573928833) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8786169588565826) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.35649625957012177) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.33451490104198456) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07977671548724174) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44840389490127563) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9278550744056702) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4172661155462265) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287012338638) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736663818359375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (maxDuration_2 <= 0.30672870576381683) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20013290643692017) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.17851174622774124) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4902231693267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.022966206073761) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07390185445547104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23117153346538544) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.702006757259369) { + if (maxDuration_2 <= 0.3560301810503006) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.39395439624786377) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.670403003692627) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7546965777873993) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4747615456581116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9120322167873383) { + if (maxDuration_2 <= 0.2409800961613655) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2929334044456482) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (averageDuration_2 <= -0.3023112267255783) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.16804800182580948) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20982589572668076) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7935594916343689) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5405782759189606) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27295316755771637) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (maxDuration_2 <= 0.1466171219944954) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.20230043679475784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.0668092630803585) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7770294547080994) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (maxDuration_2 <= 0.22267382591962814) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533350795507431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12221493571996689) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7230017483234406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35910236835479736) { + if (averageDuration_2 <= -0.23228463530540466) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5126733183860779) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.969329833984375) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8614085912704468) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.588534951210022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5228553414344788) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4673050791025162) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.15532471984624863) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.17409542202949524) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.15728962421417236) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.03609041962772608) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.8303110599517822) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19882531464099884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.6053611040115356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.08162709325551987) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1568768620491028) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12607022374868393) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27688831090927124) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.12537280842661858) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7131112217903137) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.09877948462963104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + if (averageDuration_2 <= -0.09110592678189278) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.2684951424598694) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1254468448460102) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7445935308933258) { + if (averageDuration_2 <= 0.20809295028448105) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2776985466480255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.015873609576374292) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (averageDuration_2 <= 0.010482713347300887) { + if (maxDuration_2 <= 0.2979351580142975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5126439779996872) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05635959282517433) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29589296877384186) { + if (averageDuration_2 <= -0.25956524163484573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.7158921957015991) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40491238236427307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.029112407006323338) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.008003653027117252) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6236535012722015) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.034113602712750435) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08858705312013626) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32487206161022186) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.22645554691553116) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11221031844615936) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1048748679459095) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1828387826681137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33027519285678864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.04490944929420948) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2425139918923378) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456615447998) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398807287216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.28870557248592377) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (averageDuration_2 <= 0.12272057682275772) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.41405148804187775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8023677170276642) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8481349349021912) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.23408861458301544) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6013438403606415) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18487103283405304) { + if (averageDuration_2 <= 0.38395413756370544) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4920502007007599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39174915850162506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05637750402092934) { + if (maxDuration_2 <= 1.9776089787483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2517904192209244) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8706097602844238) { + if (averageDuration_2 <= -0.1930968463420868) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.8464657962322235) { + if (averageDuration_2 <= -0.2548300325870514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6095828413963318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (maxDuration_2 <= 0.6759397387504578) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028930187225342) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.35163094103336334) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5647778511047363) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.04261348582804203) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.5832354724407196) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (maxDuration_2 <= 0.8502392470836639) { + if (averageDuration_2 <= -0.12602166831493378) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3378899097442627) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4795044809579849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.33207377791404724) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 1.8622652292251587) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3964366763830185) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5157051980495453) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6338953971862793) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.6206255853176117) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6191380023956299) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6179587841033936) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3126780241727829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.3381130695343018) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.04049695748835802) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (maxDuration_2 <= 1.1037593483924866) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5393121540546417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.1703981161117554) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.98851677775383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.733877420425415) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7308622300624847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (averageDuration_2 <= 0.0504826083779335) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484481930732727) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7485483288764954) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { + if (averageDuration_2 <= -0.47143277525901794) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7058610022068024) { + if (averageDuration_2 <= 0.06334415450692177) { + if (maxDuration_2 <= 0.7302075922489166) { + if (averageDuration_2 <= -0.18529465794563293) { + if (maxDuration_2 <= 0.6953120231628418) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (averageDuration_2 <= 0.04929473903030157) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 0.1273183897137642) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (numDurations_2 <= -0.12976674735546112) { + if (maxDuration_2 <= 0.6124829053878784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2028830498456955) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31320442259311676) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.151602029800415) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8112029433250427) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484309077262878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.508751779794693) { + if (averageDuration_2 <= -0.12054255604743958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5512841641902924) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7447766661643982) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.6192526817321777) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.45268799364566803) { + if (maxDuration_2 <= 1.3366631865501404) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13679712265729904) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.6220437586307526) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (averageDuration_2 <= 0.3065025508403778) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.435962438583374) { + if (maxDuration_2 <= 0.7321374714374542) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8191148638725281) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.6892729997634888) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.33249492943286896) { + if (averageDuration_2 <= 0.25916415452957153) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17430027574300766) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.5466925799846649) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13084669411182404) { + if (averageDuration_2 <= 0.18569526821374893) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7210254371166229) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (averageDuration_2 <= 0.3479827791452408) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2842828780412674) { + if (averageDuration_2 <= 0.2959175258874893) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6460579633712769) { + if (maxDuration_2 <= 1.4430540204048157) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + if (maxDuration_2 <= 3.211769700050354) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.007237492129206657) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7455012202262878) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.745991587638855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 2.2415308952331543) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11062952503561974) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.51711505651474) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.42193692922592163) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5509213507175446) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3922964781522751) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.390332356095314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.30061179399490356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.008863927330821753) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.09443336725235) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3161342293024063) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0810039043426514) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.173933207988739) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2306938171386719) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8041383922100067) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.20388202369213104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (maxDuration_2 <= 3.337059497833252) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17179327458143234) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 2.6414151191711426) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13095342740416527) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6390779614448547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5836866199970245) { + if (averageDuration_2 <= -0.17834172397851944) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8423057794570923) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6361984312534332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.13746867328882217) { + if (maxDuration_2 <= 0.6155371963977814) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.46571849286556244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.344773069024086) { + if (averageDuration_2 <= -0.24836672097444534) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.42405539751052856) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177308797836304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.4580065608024597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09480652958154678) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 6.886106014251709) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.43848101794719696) { + if (maxDuration_2 <= 5.924017429351807) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40637898445129395) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (averageDuration_2 <= -0.3223971873521805) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (maxDuration_2 <= 1.2119837403297424) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.7185242176055908) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 3.100911259651184) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8875992894172668) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6706474721431732) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18268565088510513) { + if (maxDuration_2 <= 0.7393201589584351) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 1.6309821605682373) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2201882600784302) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5201438069343567) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 3.5850659608840942) { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.31061211228370667) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7633680999279022) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199840635061264) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9045552313327789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.515501469373703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5986413955688477) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7322549521923065) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8721798360347748) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7804926037788391) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.747398316860199) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.4642040580511093) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.2583402693271637) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.777624100446701) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 5.826171636581421) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.590164065361023) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1612403467297554) { + if (averageDuration_2 <= -0.033431531861424446) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1858297921717167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09276749566197395) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.526071161031723) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3185248523950577) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.419750839471817) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05939977802336216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.008437632117420435) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.0488834977149963) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3603290915489197) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0757729634642601) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40191371738910675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21233825385570526) { + if (averageDuration_2 <= 0.6666126549243927) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3264668583869934) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5378614962100983) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8557784855365753) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.870782196521759) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.506699800491333) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.6761149764060974) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6347606778144836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.4736660569906235) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (maxDuration_2 <= 1.2001611590385437) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1371594071388245) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (averageDuration_2 <= 0.650501549243927) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.7960829138755798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08600029349327087) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.275539368391037) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.6985235214233398) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2321552112698555) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.027943328022956848) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.08602035045623779) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1272754669189453) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4932494163513184) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7596176266670227) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1933276727795601) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.00044530520972330123) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4206101894378662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9242295920848846) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.411447286605835) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20784858614206314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 2.2347483038902283) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913831710815) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.012378409504890442) { + if (averageDuration_2 <= 0.24102335423231125) { + if (numDurations_2 <= 3.8542970418930054) { + if (maxDuration_2 <= 3.883361339569092) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0336969494819641) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (maxDuration_2 <= -0.016399614047259092) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5077577829360962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8521566092967987) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3657059967517853) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.9360241293907166) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5085129737854004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.331823706626892) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4961337149143219) { + if (maxDuration_2 <= 0.3654137998819351) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3133798474445939) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 3.3992879390716553) { + if (averageDuration_2 <= 0.3995504826307297) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6373989880084991) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + if (maxDuration_2 <= 1.3425568342208862) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.6292269229888916) { + if (maxDuration_2 <= 0.3169380724430084) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.5477566719055176) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0318717658519745) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40207982063293457) { + if (maxDuration_2 <= 0.43722833693027496) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { + if (averageDuration_2 <= -0.16931356757413596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4039691984653473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 0.18696018308401108) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6803672909736633) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 2.3888806104660034) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07794856652617455) { + if (maxDuration_2 <= 2.1608113050460815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.863024592399597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.4059672355651855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1173449754714966) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284968852997) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7513307929039001) { + if (maxDuration_2 <= 2.3169949054718018) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5111016929149628) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { + if (maxDuration_2 <= 0.45412634313106537) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 1.4651947617530823) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5542886853218079) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (maxDuration_2 <= 0.2450222671031952) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3477352261543274) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593592286109924) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (maxDuration_2 <= 0.009357767645269632) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.43328239023685455) { + if (averageDuration_2 <= -0.4358310103416443) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.210843525826931) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.12322219088673592) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7475498020648956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1722413897514343) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9105602204799652) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0242519676685333) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (maxDuration_2 <= 2.1212406158447266) { + if (maxDuration_2 <= 0.0768008641898632) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8607339262962341) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.018952965736389) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485678493976593) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.740801215171814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5336331725120544) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1355241537094116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812396168708801) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6487295627593994) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8951848447322845) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1532800197601318) { + if (averageDuration_2 <= 0.3574665039777756) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.050901412963867) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.519687294960022) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + if (averageDuration_2 <= 0.26596584916114807) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.01268397830426693) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3221363425254822) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.9133753776550293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.3693881034851074) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.32696136832237244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3763646483421326) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.016563892364502) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.507827639579773) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7480499446392059) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (maxDuration_2 <= 0.4199046641588211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.472336232662201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1321731805801392) { + if (maxDuration_2 <= 0.32185399532318115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2217394709587097) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9711636304855347) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0262272357940674) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8796047568321228) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.6652236878871918) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17848403006792068) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.3681333214044571) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { + if (averageDuration_2 <= -0.637970894575119) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1700569987297058) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.444263219833374) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9596558213233948) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8781578540802002) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7281722128391266) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0162522792816162) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8712836802005768) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.6967872381210327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9958769381046295) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (maxDuration_2 <= 2.5329322814941406) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.454704999923706) { + if (maxDuration_2 <= 0.4597287029027939) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20815634727478027) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5467133820056915) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5567779839038849) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (averageDuration_2 <= 0.6449016332626343) { + if (averageDuration_2 <= 0.633177250623703) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.3538119792938232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3401797115802765) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40457236766815186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 2.985949754714966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2827761620283127) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.547249913215637) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (maxDuration_2 <= 0.8501431941986084) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.050901412963867) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8555848300457001) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.386396884918213) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0971235036849976) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { + if (maxDuration_2 <= 4.656016826629639) { + if (averageDuration_2 <= 0.2558552622795105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4734087735414505) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.643548846244812) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.185565710067749) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 5.6706976890563965) { + if (maxDuration_2 <= 3.8263707160949707) { + if (averageDuration_2 <= 0.4018881171941757) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 3.625117778778076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6765446662902832) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + if (maxDuration_2 <= 5.392617702484131) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.0422221422195435) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12992041558027267) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643927812576294) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + if (maxDuration_2 <= 4.266775369644165) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.6862711310386658) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 0.4006679654121399) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.30679476261138916) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8145439028739929) { + if (maxDuration_2 <= 5.111055850982666) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18521007895469666) { + if (maxDuration_2 <= 1.7629531621932983) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4005657136440277) { + if (averageDuration_2 <= -0.49008750915527344) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3916861116886139) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { + if (averageDuration_2 <= -0.0711655430495739) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8303315341472626) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (averageDuration_2 <= -0.05755419284105301) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5261990427970886) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.002367605920881033) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.2882041484117508) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (averageDuration_2 <= -0.11562366783618927) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.2349066287279129) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670703738928) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414793252945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.27706578373908997) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670051813126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.9725836217403412) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4329824149608612) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3596280366182327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6102865934371948) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (averageDuration_2 <= -0.02345554530620575) { + if (averageDuration_2 <= -0.3465505987405777) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6799042820930481) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4125160872936249) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.05006267502903938) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.212310314178467) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2977767884731293) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5940277874469757) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42623719573020935) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43208564817905426) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.43764111399650574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.5140042304992676) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35503965616226196) { + if (maxDuration_2 <= 0.24061790853738785) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (maxDuration_2 <= 0.19049593806266785) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.39207449555397034) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (averageDuration_2 <= -0.01755179977044463) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6749744713306427) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24484729766845703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178307533264) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.16723784804344177) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.599466860294342) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953776597976685) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2587443590164185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06953328102827072) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.36018379032611847) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4374353736639023) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (averageDuration_2 <= -0.0786764994263649) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.06748113315552473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.17071663588285446) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2023368775844574) { + if (maxDuration_2 <= 0.08100781589746475) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37988099455833435) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.284114807844162) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (averageDuration_2 <= -0.504952996969223) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6233090758323669) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.2558213174343109) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2956107407808304) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09400257840752602) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21152733266353607) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3334933966398239) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236781001091003) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5537951290607452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.24432819336652756) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28796590864658356) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.009289418580010533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.563823789358139) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.850100576877594) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541325807571) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.050962820649147034) { + if (numDurations_2 <= 3.2851450443267822) { + if (maxDuration_2 <= -0.00455429358407855) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.3760383874177933) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.24339378625154495) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.1603493019938469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2625754326581955) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.26987220346927643) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2853277772665024) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21207299828529358) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.2241146564483643) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9464623630046844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22158926725387573) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26862944662570953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508275985718) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040390849113464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.012018587440252304) { + if (averageDuration_2 <= -0.018513771705329418) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345905259251595) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.8143337965011597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6754757165908813) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.7037045955657959) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40611760318279266) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.29171763360500336) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.026467518880963326) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3669063150882721) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815161705017) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5838739275932312) { + if (maxDuration_2 <= 1.2148786187171936) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24865853786468506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721573352814) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 0.3087778091430664) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8727467060089111) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4397130012512207) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49243196845054626) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2545369863510132) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7695936262607574) { + if (maxDuration_2 <= 1.6226548552513123) { + if (averageDuration_2 <= -0.1842714548110962) { + if (maxDuration_2 <= 0.7798659205436707) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4672095626592636) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8003976345062256) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7568724155426025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.1766730546951294) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5576425194740295) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23622824251651764) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.27154649794101715) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.045294132083654404) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7346155643463135) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20376486331224442) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1958169341087341) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.564697802066803) { + if (maxDuration_2 <= 0.22109846025705338) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.644312173128128) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2944450378417969) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32033464312553406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.06316339969635) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3627431094646454) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.2289574146270752) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2364568710327148) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.8165784180164337) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287291735411) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.5612579137086868) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484406530857086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35129597783088684) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3138785809278488) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3651854991912842) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4942823797464371) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2029850482940674) { + if (averageDuration_2 <= 0.7512552440166473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9766682684421539) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5962963998317719) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6604832112789154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.861770749092102) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8404964208602905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.603541374206543) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.720045804977417) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0967368483543396) { + if (maxDuration_2 <= 0.21898876130580902) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12923303991556168) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3709937930107117) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835330963135) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.11133947968482971) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1395991444587708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3102819621562958) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1402398720383644) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.9790320694446564) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (averageDuration_2 <= 0.647126317024231) { + if (averageDuration_2 <= 0.6223336756229401) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.189287006855011) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= 1.2641422748565674) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5146777927875519) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5722512304782867) { + if (maxDuration_2 <= 0.5580757856369019) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (maxDuration_2 <= 0.2395162582397461) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (maxDuration_2 <= 0.10211512818932533) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.59490168094635) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.06567713618278503) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (maxDuration_2 <= -0.00026384844386484474) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11663258820772171) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.347576379776001) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (averageDuration_2 <= 0.4105546176433563) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507169485092) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515098571777) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5703380405902863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24216292798519135) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09554325044155121) { + if (maxDuration_2 <= 0.591940313577652) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.4334671050310135) { + if (averageDuration_2 <= -0.05438607931137085) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1981149911880493) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7312967777252197) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9557093977928162) { + if (averageDuration_2 <= -0.4332282394170761) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144360721111298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.26461537182331085) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.2405899614095688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2006407976150513) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.47328467667102814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.326260566711426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09997040778398514) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15367309004068375) { + if (averageDuration_2 <= -0.2456832230091095) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14436258375644684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.44567954540252686) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6165053844451904) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5174239277839661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.233595609664917) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9104954898357391) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46606843173503876) { + if (maxDuration_2 <= 0.006105792126618326) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4948379844427109) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (averageDuration_2 <= -0.060847021639347076) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32389242947101593) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (maxDuration_2 <= 0.1284346655011177) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.3373135179281235) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (maxDuration_2 <= 0.028464345261454582) { + if (averageDuration_2 <= -0.20067235827445984) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5455034971237183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7538002729415894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.42289362847805023) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19059136509895325) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2814564108848572) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.22981609404087067) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.08745843172073364) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.23933130502700806) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35513000190258026) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404849529266) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.340190589427948) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08795669302344322) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (averageDuration_2 <= -0.23837218433618546) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9757799506187439) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1762663498520851) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.25750577449798584) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9427586495876312) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798433244228363) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.03266109898686409) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.1954955905675888) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2003083229064941) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7061541080474854) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1694013774394989) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.15917666256427765) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19570736587047577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.6332000494003296) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8922097086906433) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (averageDuration_2 <= -0.4548991918563843) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3077685609459877) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0775180496275425) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.200829565525055) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.325911283493042) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.264043152332306) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.4923414885997772) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740303099155426) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (averageDuration_2 <= -0.1628672480583191) { + if (maxDuration_2 <= 0.238971546292305) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22695346921682358) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.39184698462486267) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (maxDuration_2 <= 0.16849935799837112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.19052860885858536) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (averageDuration_2 <= -0.20970242470502853) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0714032649993896) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3650086671113968) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.08676952123641968) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4137696176767349) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.21426266431808472) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1754255294799805) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.19641231000423431) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (averageDuration_2 <= 0.3357199877500534) { + if (maxDuration_2 <= 0.19469265639781952) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.3010910302400589) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36013662815093994) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46160899102687836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5088231265544891) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5078662931919098) { + if (averageDuration_2 <= 0.07704402506351471) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.00955027062445879) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11448447220027447) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3103668689727783) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.2057140469551086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070023775100708) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 0.24020279943943024) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3551264554262161) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.011409632861614227) { + if (maxDuration_2 <= 0.015003126580268145) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10219529643654823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4689117670059204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.4090394079685211) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.18726923316717148) { + if (maxDuration_2 <= 0.11821287497878075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04032540135085583) { + if (maxDuration_2 <= 0.4042450040578842) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.040434835478663445) { + if (averageDuration_2 <= -0.04784642904996872) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1417597234249115) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (maxDuration_2 <= 0.1968277022242546) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9661673307418823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5891313254833221) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.013557552359998226) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6213195323944092) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0763629823923111) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1315220594406128) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12629256397485733) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5120928287506104) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740303099155426) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7030073404312134) { + if (averageDuration_2 <= -0.12176282703876495) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10737277939915657) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5017814785242081) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2471645325422287) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (maxDuration_2 <= 1.0187520384788513) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03747232258319855) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17631423473358154) { + if (averageDuration_2 <= 0.39042238891124725) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (maxDuration_2 <= 0.6244499981403351) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12649182975292206) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + if (averageDuration_2 <= 0.26189276576042175) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3080918490886688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28542277216911316) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35884347558021545) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30719996988773346) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921536922454834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20676742494106293) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2022235244512558) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.30748067796230316) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06601608544588089) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5903348922729492) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.2432587966322899) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26420241594314575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3126506507396698) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1915278360247612) { + if (averageDuration_2 <= 0.23476268351078033) { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= -0.14075449854135513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.043676257133484) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.5290503799915314) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178903579712) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.9304614961147308) { + if (averageDuration_2 <= 0.523498922586441) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02982225827872753) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3661118149757385) { + if (averageDuration_2 <= -0.2360268235206604) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.349144771695137) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2877402901649475) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06261585839092731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.4747196286916733) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1477399542927742) { + if (averageDuration_2 <= 0.531990647315979) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7270525693893433) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9306365549564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.022392213344574) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03219803236424923) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7134906649589539) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.483604371547699) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.12772595882415771) { + if (averageDuration_2 <= -0.30329519510269165) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.6620207726955414) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (numDurations_2 <= -1.2680706679821014) { + if (averageDuration_2 <= 0.6567644476890564) { + if (averageDuration_2 <= 0.4407403916120529) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0971235036849976) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4591042846441269) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6387370228767395) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7606276273727417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7692232131958008) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5375382006168365) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13610926270484924) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 1.0951229333877563) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (maxDuration_2 <= 1.0110780596733093) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.047946153208613396) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.5647449493408203) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.5116665959358215) { + if (maxDuration_2 <= 0.5094125866889954) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.823574423789978) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6587873995304108) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7184686958789825) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.15830105543136597) { + if (averageDuration_2 <= -0.25264767557382584) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2296210527420044) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4334494471549988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.5406128168106079) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.399016797542572) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.013062774669378996) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.12039435282349586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.346752166748047) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153710365295) { + if (maxDuration_2 <= 0.6079950332641602) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (averageDuration_2 <= -0.4831068068742752) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6850058436393738) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.10628174617886543) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.270564317703247) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6826225817203522) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3886886835098267) { + if (averageDuration_2 <= 0.6465851366519928) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.9989573061466217) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49198198318481445) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6604642868041992) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.608759045600891) { + if (averageDuration_2 <= 0.149479478597641) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.873420536518097) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.3776618391275406) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4872465431690216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4670807719230652) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9893559217453003) { + if (maxDuration_2 <= 0.2875714749097824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.5634623765945435) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2735583335161209) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2322942242026329) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5640164613723755) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1599389910697937) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26053740084171295) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3393375277519226) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.037634821608662605) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4341423660516739) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.300660490989685) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5481379926204681) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74850994348526) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.22807607799768448) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + if (averageDuration_2 <= -0.44030220806598663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.35109637677669525) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2442367970943451) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (maxDuration_2 <= 0.04911096580326557) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5336957275867462) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31663385033607483) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.9177788197994232) { + if (maxDuration_2 <= 0.9048139750957489) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101411759853363) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5393618047237396) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1476746797561646) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8255003392696381) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.04987577348947525) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2542556524276733) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34488406777381897) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5997462868690491) { + if (maxDuration_2 <= 0.1228933222591877) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1924630403518677) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= -0.02384578250348568) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.493928551673889) { + if (maxDuration_2 <= 0.3424929231405258) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781908035278) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5536487102508545) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (maxDuration_2 <= 0.24306710064411163) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (averageDuration_2 <= -0.34951135516166687) { + if (averageDuration_2 <= -0.5102205872535706) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.2355981022119522) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7935495674610138) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.19909172505140305) { + if (averageDuration_2 <= -0.5917091369628906) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.709421396255493) { + if (averageDuration_2 <= -0.3374997675418854) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7052638530731201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5206778347492218) { + if (maxDuration_2 <= 0.2138574719429016) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.963934600353241) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.8050788938999176) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8608003258705139) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.7359728813171387) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0310637950897217) { + if (maxDuration_2 <= 0.6153853833675385) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.1602839156985283) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.148585021495819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (maxDuration_2 <= 0.0029070632881484926) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= -0.11169939115643501) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5737024247646332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7684641182422638) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940382003784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.2279265746474266) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.3634660094976425) { + if (averageDuration_2 <= -0.15652602910995483) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7951367497444153) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.648976445198059) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5488219261169434) { + if (maxDuration_2 <= 1.0876792669296265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8362123668193817) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8949843645095825) { + if (averageDuration_2 <= 0.36479055881500244) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0398183465003967) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248238757252693) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.31476010382175446) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (maxDuration_2 <= 0.22383133322000504) { + if (averageDuration_2 <= 0.2665567994117737) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.2662731409072876) { + if (averageDuration_2 <= 0.17798041552305222) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (maxDuration_2 <= 0.5109928846359253) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8166762888431549) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5365391075611115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.471769571304321) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8380617797374725) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7006752490997314) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306547224521637) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289728224277496) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08066484704613686) { + if (maxDuration_2 <= 0.03190127480775118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13775229454040527) { + if (averageDuration_2 <= 0.16966138780117035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8814636766910553) { + if (maxDuration_2 <= 0.4612787216901779) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7195698320865631) { + if (maxDuration_2 <= 0.33206577599048615) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1721528396010399) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6631757915019989) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.609273076057434) { + if (averageDuration_2 <= -0.4051600247621536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (averageDuration_2 <= -0.6397821605205536) { + if (maxDuration_2 <= 0.11055146530270576) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223794698715) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5737563967704773) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7447831928730011) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367631524801254) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.1934889554977417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.055057622492313385) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.03730260394513607) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.29769961535930634) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.014404535293579) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12158455327153206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13235384225845337) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.12640100717544556) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9296188056468964) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0501359105110168) { + if (maxDuration_2 <= 0.20252370089292526) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26100869476795197) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7554371058940887) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948375284671783) { + if (averageDuration_2 <= -0.5222404301166534) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4923478662967682) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6512565314769745) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.4140491485595703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.841257691383362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02788958977907896) { + if (averageDuration_2 <= -0.42026522755622864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (averageDuration_2 <= -0.3288869708776474) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.806822419166565) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7382455170154572) { + if (maxDuration_2 <= 0.17132080346345901) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9592720866203308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18054499477148056) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6591601371765137) { + if (maxDuration_2 <= 2.008854866027832) { + if (averageDuration_2 <= 0.03735444135963917) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.018952965736389) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.038451360538601875) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.4475434422492981) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.601545661687851) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014058990869671106) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { + if (maxDuration_2 <= 3.182745337486267) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 5.666366100311279) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3856501877307892) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (maxDuration_2 <= 3.485931158065796) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9473508894443512) { + if (averageDuration_2 <= 0.39343005418777466) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + if (maxDuration_2 <= 2.7372950315475464) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.41800060868263245) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4634422063827515) { + if (maxDuration_2 <= 2.4467395544052124) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 1.578337848186493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01674596732482314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.18390513956546783) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21660030633211136) { + if (maxDuration_2 <= 4.910945415496826) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (maxDuration_2 <= 3.815971255302429) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5715272426605225) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 4.981967210769653) { + if (averageDuration_2 <= 0.4226730018854141) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.45147131383419037) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30288489162921906) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.352748155593872) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165755271912) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29440927505493164) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8468046188354492) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2647775262594223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10614394396543503) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.0642496682703495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2528754621744156) { + if (averageDuration_2 <= -0.017338799312710762) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20099686086177826) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.38652369379997253) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4294944703578949) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= 4.909792900085449) { + if (averageDuration_2 <= -0.198727548122406) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7820281088352203) { + if (averageDuration_2 <= -0.4681995064020157) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26573875546455383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49579326808452606) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6164599061012268) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.035555776208639145) { + if (averageDuration_2 <= -0.09163215011358261) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5795921385288239) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0226173400878906) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.18484089523553848) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.02609582617878914) { + if (maxDuration_2 <= 1.2965781688690186) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963939785957336) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2375742197036743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23903899639844894) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5708679258823395) { + if (averageDuration_2 <= 0.319341316819191) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591893777251244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6358306407928467) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0258170664310455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8653557300567627) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9978135228157043) { + if (maxDuration_2 <= 3.0989508628845215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6876242756843567) { + if (averageDuration_2 <= -0.02123983483761549) { + if (maxDuration_2 <= 1.330518901348114) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11954734101891518) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3495359569787979) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5400809645652771) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 1.7244536876678467) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4429995268583298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (averageDuration_2 <= -0.18221993744373322) { + if (averageDuration_2 <= -0.46643994748592377) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.832880437374115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4787856638431549) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 2.572287678718567) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3038039058446884) { + if (averageDuration_2 <= -0.06728924065828323) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14966480433940887) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7842196524143219) { + if (maxDuration_2 <= 2.1740193367004395) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6557387709617615) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.4388421773910522) { + if (maxDuration_2 <= 1.3678559064865112) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6130359321832657) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7291649281978607) { + if (averageDuration_2 <= -0.20401102304458618) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (maxDuration_2 <= 2.8405961990356445) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536155462265) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0211151242256165) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 2.3012441396713257) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7122454047203064) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0133654475212097) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7215404212474823) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8237243294715881) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4501678943634033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (numDurations_2 <= 1.8622651100158691) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7043106555938721) { + if (maxDuration_2 <= 1.468436598777771) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.42650002241134644) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.014460311038419604) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8830764293670654) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1519950106739998) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= 2.360835909843445) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23324685543775558) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284670829773) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41893546283245087) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.030721173621714115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 2.0507278442382812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4203786849975586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3946537375450134) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1699317991733551) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27762463688850403) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36891959607601166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5319692194461823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 2.6360456943511963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8777981996536255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9890867471694946) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3231569826602936) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.42911046743392944) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.242385745048523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + if (maxDuration_2 <= 0.4649232178926468) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2641295790672302) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { + if (maxDuration_2 <= 0.06713099218904972) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825266361236572) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08409106731414795) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2070707008242607) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5974637269973755) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4602627158164978) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4690933972597122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.4282166212797165) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13024095445871353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.055903466418385506) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.8538601398468018) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4064010977745056) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (maxDuration_2 <= 0.2545679360628128) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (maxDuration_2 <= 0.43389272689819336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15984783321619034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6669895648956299) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6042918562889099) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7460454404354095) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4235254526138306) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10923456400632858) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (maxDuration_2 <= 0.34415431320667267) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3823658227920532) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7036847472190857) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6956122517585754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7430383861064911) { + if (maxDuration_2 <= 0.23097094893455505) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.13901548832654953) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5139202773571014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.692499577999115) { + if (averageDuration_2 <= 0.39394593238830566) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623380899429321) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16271371394395828) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.3266964703798294) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.19511732459068298) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617429971694946) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7617704272270203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3666815757751465) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (maxDuration_2 <= 0.22189629822969437) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6427231132984161) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.16722805052995682) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (averageDuration_2 <= 0.759729415178299) { + if (averageDuration_2 <= 0.7402538657188416) { + if (averageDuration_2 <= 0.4737645387649536) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4932494163513184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15044831112027168) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (maxDuration_2 <= 0.3349025100469589) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4329689145088196) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 0.8788341879844666) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24553610384464264) { + if (averageDuration_2 <= 0.20318251103162766) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.3737525939941406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334689199924469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4546836018562317) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.270169273018837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33310049772262573) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7439887523651123) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.36807067692279816) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14624148607254028) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8027482628822327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.6672534942626953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.16123215854167938) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.3516284227371216) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.07683756202459335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.020525816828012466) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4947177469730377) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (averageDuration_2 <= 0.38153761625289917) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8454057574272156) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.232944056391716) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5912105441093445) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.9434725046157837) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.498771011829376) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.3255631923675537) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.8771063089370728) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2077157497406006) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463053226471) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.15843714028596878) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.582572817802429) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.31164078414440155) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.060017228126526) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.302473545074463) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4602354168891907) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1596840620040894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.17295461893081665) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2288528084754944) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.2918156832456589) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2990409135818481) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7354987263679504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8035789132118225) { + if (averageDuration_2 <= 0.7162552773952484) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.4652613401412964) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.1468046009540558) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2432098388671875) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + if (maxDuration_2 <= 0.11646275408565998) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12426672503352165) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0026832818984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4421444535255432) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17399810999631882) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4627494364976883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.3346111476421356) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9587630033493042) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607649445533752) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3681035339832306) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2705179452896118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3691399693489075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (maxDuration_2 <= 0.39605432748794556) { + if (averageDuration_2 <= 0.3863515257835388) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3358411639928818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4419679343700409) { + if (maxDuration_2 <= 0.41109326481819153) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.16544219851493835) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (maxDuration_2 <= 0.02103857323527336) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.33809444308280945) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.484076499938965) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.006260633468628) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28045739233493805) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.9353829622268677) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 0.03758057951927185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.3192882388830185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + if (averageDuration_2 <= 0.286331444978714) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.768178939819336) { + if (maxDuration_2 <= 0.2374088540673256) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.01505080284550786) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.352748155593872) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0975580215454102) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4413849115371704) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3360027074813843) { + if (averageDuration_2 <= -0.06993165984749794) { + if (maxDuration_2 <= 0.30900058150291443) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.21650774776935577) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.7480875551700592) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976390838623047) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.10821932554245) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607385396957397) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4592827558517456) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.3494577407836914) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.3182414323091507) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7108749151229858) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.37633462250232697) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6926724910736084) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.25773176550865173) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888539791107) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5930910110473633) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 0.41057874262332916) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612544775009155) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199315547943) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.3846242427825928) { + if (averageDuration_2 <= 0.30631570518016815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5662427842617035) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5678754448890686) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3727903962135315) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 1.7909623980522156) { + if (maxDuration_2 <= 0.7245444655418396) { + if (averageDuration_2 <= 0.5259277820587158) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3064705431461334) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (averageDuration_2 <= -0.03269064240157604) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1982994675636292) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4337494373321533) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16236130148172379) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1122801303863525) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.3175666481256485) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (averageDuration_2 <= -0.2930971831083298) { + if (maxDuration_2 <= 0.4932436943054199) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4423782229423523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4605891108512878) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.41546398401260376) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 0.33926577866077423) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.702899217605591) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5665489435195923) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.5477566719055176) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.151027202606201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8089553713798523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.029220184311270714) { + if (averageDuration_2 <= -0.35949476063251495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3612300753593445) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4429798126220703) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40162627398967743) { + if (averageDuration_2 <= -0.33695654571056366) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.080251395702362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23657985031604767) { + if (maxDuration_2 <= 0.6224770247936249) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3957411050796509) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.26358339190483093) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.48647381365299225) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.4843236207962036) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 0.2447957992553711) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.03269314020872116) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17675691843032837) { + if (numDurations_2 <= -0.12976674735546112) { + if (maxDuration_2 <= 0.5635538399219513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8274345993995667) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.22494500875473022) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.016571398824453354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2710963487625122) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37983131408691406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (maxDuration_2 <= 0.6883193552494049) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (averageDuration_2 <= 0.08237481862306595) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4626663327217102) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.2969357818365097) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38254110515117645) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485684156417847) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.5420159101486206) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.5542387068271637) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272780418396) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591094017029) { + if (maxDuration_2 <= 0.5500800609588623) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911767244339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1763165071606636) { + if (numMissedDeadlines_2 <= 4.563007950782776) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462079107761383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461315095424652) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606261849403381) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165159225464) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14925425499677658) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.5853307247161865) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8703529834747314) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.1735504865646362) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3718595430254936) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23871616274118423) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4774004966020584) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1239492893218994) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.26533639430999756) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5082795917987823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.14615275710821152) { + if (maxDuration_2 <= 1.162107527256012) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485603094100952) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4625609964132309) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.9883725345134735) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.1443113312125206) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888539791107) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.65778249502182) { + if (maxDuration_2 <= 0.981174498796463) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.0809937715530396) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5417258441448212) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7944985032081604) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0048857927322388) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15142414346337318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117392778396606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.8389183282852173) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.6557488441467285) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9380844235420227) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615720510482788) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1738549917936325) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.11063998937606812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7212187647819519) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.142114996910095) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.7539262473583221) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4968719333410263) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17573968321084976) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15608662366867065) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5901694595813751) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14401210844516754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.224535882472992) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.5809946656227112) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4256374388933182) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6192947626113892) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17034465819597244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8949843645095825) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (averageDuration_2 <= 0.08805647119879723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5417258441448212) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 1.5916523337364197) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7072669267654419) { + if (averageDuration_2 <= 0.03242693655192852) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.17228609323501587) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + if (averageDuration_2 <= 0.5928299427032471) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.9542267918586731) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.5482349395751953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4636659026145935) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.97825688123703) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622002840042114) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6927345991134644) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (maxDuration_2 <= 0.8587973415851593) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.316119909286499) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.51321941614151) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.584539920091629) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { + if (maxDuration_2 <= 3.2875101566314697) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 3.3500877618789673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 3.0232993364334106) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.092849254608154) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 2.3364663124084473) { + if (averageDuration_2 <= 0.3411664217710495) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0555312037467957) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701804161072) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.648976445198059) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8631930947303772) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.5494454503059387) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070024073123932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.4362072944641113) { + if (maxDuration_2 <= 4.432061433792114) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { + if (averageDuration_2 <= 0.7457267045974731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8908034265041351) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615456461906433) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.4695110470056534) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.24652601033449173) { + if (maxDuration_2 <= 0.5770659148693085) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (maxDuration_2 <= 0.36416269838809967) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.3869647681713104) { + if (maxDuration_2 <= 0.228671133518219) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17070672661066055) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8386341035366058) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8780616521835327) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14625396579504013) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.30469673871994) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.853439599275589) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3480595350265503) { + if (maxDuration_2 <= 0.0019319088896736503) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.304485559463501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3251873254776) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { + if (maxDuration_2 <= 0.16205382347106934) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17518071085214615) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5687283873558044) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6245782375335693) { + if (averageDuration_2 <= -0.46553266048431396) { + if (averageDuration_2 <= -0.48726001381874084) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14163348078727722) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284670829773) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (averageDuration_2 <= -0.42365221679210663) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.11029172502458096) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622228145599365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.40358296036720276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (numDurations_2 <= 7.269208669662476) { + if (maxDuration_2 <= 0.2532256096601486) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1489261984825134) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.778379797935486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30817437171936035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5458608269691467) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2128134369850159) { + if (averageDuration_2 <= -0.41881464421749115) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49446921050548553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8363194167613983) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23798730969429016) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (averageDuration_2 <= -0.47706229984760284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29736481606960297) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04257108271121979) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21516287326812744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.030815708450973034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7312291860580444) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617557525634766) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.879536509513855) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1079137846827507) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.41479460895061493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.28744223713874817) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (averageDuration_2 <= -0.263033851981163) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (maxDuration_2 <= 0.08310211077332497) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504843473434448) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8025574684143066) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5342928767204285) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6583120822906494) { + if (maxDuration_2 <= 0.23145464807748795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.45153340697288513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.883341372013092) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619413614273071) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7456344366073608) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461660921573639) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.34969064593315125) { + if (averageDuration_2 <= -0.3219815343618393) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3512469679117203) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22002233564853668) { + if (maxDuration_2 <= 0.22938043624162674) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (averageDuration_2 <= -0.3853195756673813) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462589144706726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2266959547996521) { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9381119310855865) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.13904931396245956) { + if (averageDuration_2 <= -0.3737427294254303) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619316458702087) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04197080433368683) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461845576763153) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.205658197402954) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48337236046791077) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.05921563133597374) { + if (averageDuration_2 <= -0.26436731219291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.215610109269619) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (averageDuration_2 <= -0.4224219024181366) { + if (averageDuration_2 <= -0.6485199630260468) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.37765470147132874) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611558318138123) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2302071452140808) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748422235250473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.911641538143158) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6058032512664795) { + if (averageDuration_2 <= -0.41182178258895874) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.4125157594680786) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= -0.00799873098731041) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3434019237756729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6548566222190857) { + if (maxDuration_2 <= 0.21885952353477478) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619531035423279) { + if (averageDuration_2 <= -0.6227836608886719) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (averageDuration_2 <= -0.4066706448793411) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3224920630455017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1393211483955383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319177746773) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06895006448030472) { + if (averageDuration_2 <= -0.299502357840538) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0026367604732513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20263753086328506) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { + if (maxDuration_2 <= 0.11994269490242004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0551071763038635) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2927219867706299) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.444460391998291) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5297087132930756) { + if (numDurations_2 <= 4.992600917816162) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5771615207195282) { + if (numDurations_2 <= 4.4234490394592285) { + if (averageDuration_2 <= -0.7463608682155609) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4599745273590088) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7768742442131042) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111890792847) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186872720718384) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.289841890335083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + if (numDurations_2 <= 1.5776891708374023) { + if (averageDuration_2 <= -0.47417721152305603) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 5.8463287353515625) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25230975449085236) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (maxDuration_2 <= 0.3879142701625824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.3032449036836624) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3699759989976883) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.594074934720993) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486122846603394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21843662858009338) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7303748428821564) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618543982505798) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7284773588180542) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24020425975322723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4400789737701416) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + if (averageDuration_2 <= -0.5701561570167542) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.676054000854492) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7746920883655548) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (averageDuration_2 <= -0.26591894030570984) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27514003217220306) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34710994362831116) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07932132855057716) { + if (averageDuration_2 <= -0.4028385579586029) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8002727627754211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06242578476667404) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.34450162947177887) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0875993371009827) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.21737030148506165) { + if (averageDuration_2 <= -0.6032171845436096) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4630483984947205) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2447747588157654) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619081616401672) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721573352814) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4148825109004974) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.8631931245326996) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.034897420555353165) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3119745999574661) { + if (averageDuration_2 <= -0.5034425109624863) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6393420994281769) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (averageDuration_2 <= -0.29016993939876556) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485481202602386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44852393865585327) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3049110323190689) { + if (averageDuration_2 <= -0.4972231090068817) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.3004702627658844) { + if (maxDuration_2 <= 0.010540442541241646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1042715907096863) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.2469632625579834) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.542070746421814) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15265657007694244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.19496869295835495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9736073017120361) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.745672583580017) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3851780444383621) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4534289836883545) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (averageDuration_2 <= -0.47637568414211273) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4634822010993958) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1179419495165348) { + if (maxDuration_2 <= 0.11849404126405716) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.1677878350019455) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3039478361606598) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (averageDuration_2 <= -0.4132165163755417) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.2460106015205383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1760829091072083) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.188812732696533) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.010598020628094673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.42520859837532043) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25722745060920715) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1195555329322815) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4630027413368225) { + if (averageDuration_2 <= -0.5339729487895966) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3525003492832184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5381681025028229) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7875808775424957) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4106923937797546) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5146772265434265) { + if (averageDuration_2 <= -0.34361034631729126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10625581443309784) { + if (averageDuration_2 <= -0.263743057847023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07055109366774559) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2184163331985474) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.005229495698586106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4642882943153381) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5391302704811096) { + if (averageDuration_2 <= -0.3917224407196045) { + if (numDurations_2 <= 4.4234490394592285) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23001007735729218) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2189591526985168) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4085732251405716) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4037279486656189) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.6928452253341675) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8274345993995667) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (numDurations_2 <= 10.11496877670288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + if (maxDuration_2 <= 1.807799756526947) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3220030665397644) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8636736571788788) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.6322885453701019) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4532228708267212) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617606401443481) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3241117596626282) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.8874699175357819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12880414724349976) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.6672534942626953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.548783004283905) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (averageDuration_2 <= -0.40787628293037415) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.310221254825592) { + if (averageDuration_2 <= -0.5799572169780731) { + if (averageDuration_2 <= -0.7536517083644867) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.250082850456238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616140127182007) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0625119805335999) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.63319993019104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 4.6285271644592285) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6850249469280243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.0519715547561646) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.3262604475021362) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.278771698474884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 2.137601852416992) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.43279071152210236) { + if (averageDuration_2 <= -0.028030233457684517) { + if (maxDuration_2 <= 0.22051330655813217) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13677772134542465) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (maxDuration_2 <= 0.06054849363863468) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618651866912842) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.101522386074066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03827717341482639) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.11253714188933372) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.345133662223816) { + if (maxDuration_2 <= 0.02429315261542797) { + if (averageDuration_2 <= -0.18166856467723846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616326093673706) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.028837166726589203) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2689694166183472) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4130169451236725) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03822941519320011) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233471870422) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2957223802804947) { + if (averageDuration_2 <= -0.05811733193695545) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539397239685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + if (averageDuration_2 <= -0.08933059871196747) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619433283805847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05304388329386711) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618377685546875) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39444170892238617) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07005864009261131) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4120877385139465) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05572330951690674) { + if (maxDuration_2 <= -0.008705480489879847) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (averageDuration_2 <= -0.06050151586532593) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2312130704522133) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7907251119613647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46427084505558014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= -0.005476200953125954) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392869949341) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.244322419166565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39513707160949707) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7222920358181) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485627233982086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { + if (averageDuration_2 <= -0.21237368136644363) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.03318239003419876) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.060193946585059166) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09827997162938118) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6793844103813171) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991549491882324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5198341310024261) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5126725137233734) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470267772675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.893098771572113) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.011039497796446085) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.22537189722061157) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544506549835) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461627721786499) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620019793510437) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.023615305311977863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32493704557418823) { + if (averageDuration_2 <= -0.20794106274843216) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3813329190015793) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09174468740820885) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4461706876754761) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2674808204174042) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9414147138595581) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= -0.004197099944576621) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (averageDuration_2 <= -0.10394452512264252) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2752511501312256) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.014869967941194773) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.2602974772453308) { + if (maxDuration_2 <= 0.39047472178936005) { + if (averageDuration_2 <= -0.15627028793096542) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1234126091003418) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.332435965538025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.1530783399939537) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.27533090114593506) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.6195289492607117) { + if (averageDuration_2 <= -0.1860927864909172) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.59490168094635) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.23781165480613708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 1.0661715865135193) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32573795318603516) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485733032226562) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (maxDuration_2 <= 1.6149300932884216) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (maxDuration_2 <= 0.24180826544761658) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1221141628921032) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (maxDuration_2 <= 0.8835214972496033) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2267187014222145) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.07615719363093376) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3563624396920204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19189206510782242) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618417024612427) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 1.2135262489318848) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5662542283535004) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2614276707172394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5740767419338226) { + if (maxDuration_2 <= 0.4386211633682251) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.9475353062152863) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.08678947389125824) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.21696310490369797) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05083497241139412) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4240179061889648) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.149984896183014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.3218844532966614) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.8750420808792114) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3913271725177765) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (maxDuration_2 <= 0.8056817650794983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5653949677944183) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13629667088389397) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.03618403896689415) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03773343376815319) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3350065350532532) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.6288281679153442) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6978297829627991) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617488980293274) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.003839071374386549) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5647778511047363) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4518350660800934) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13679742068052292) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5579688251018524) { + if (maxDuration_2 <= 0.4793064296245575) { + if (maxDuration_2 <= 0.21935341507196426) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (maxDuration_2 <= 0.09651780873537064) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16657786816358566) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.3569984436035156) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20548036694526672) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (averageDuration_2 <= 0.2837657779455185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (maxDuration_2 <= 0.3051028251647949) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6929609775543213) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484812438488007) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.216363549232483) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.25098615884780884) { + if (maxDuration_2 <= 0.5385511517524719) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.2211945801973343) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (maxDuration_2 <= 0.15003105252981186) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3467200696468353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2140112966299057) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.019909885246306658) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.896321952342987) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616326093673706) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615007042884827) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3408273756504059) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1858297921717167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (maxDuration_2 <= 0.11735428124666214) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09393413737416267) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + if (averageDuration_2 <= 0.28194038569927216) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4113236218690872) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.50744891166687) { + if (maxDuration_2 <= 2.0298534631729126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.8986510038375854) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (maxDuration_2 <= 0.3110293298959732) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17433183640241623) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12534869089722633) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.4071301817893982) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.4374130219221115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.6439599394798279) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36609846353530884) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.229755938053131) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20332161337137222) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470267772675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.01626251172274351) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.7939351499080658) { + if (maxDuration_2 <= 0.296785444021225) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5151970982551575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.2984625101089478) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.171896517276764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.8539550304412842) { + if (maxDuration_2 <= 0.302086278796196) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3132547438144684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37052251398563385) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.434457004070282) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.10738615319132805) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.009272754658013582) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.36195260286331177) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.04055340774357319) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1189902424812317) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2632790207862854) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= -0.021665476262569427) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964074045419693) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.2118617221713066) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + if (averageDuration_2 <= -0.09590443223714828) { + if (maxDuration_2 <= 0.8319051861763) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3922600746154785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.9529157876968384) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { + if (averageDuration_2 <= 0.02109418995678425) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.2223849818110466) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6608707904815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.022449105978012085) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619804620742798) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948376029729843) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8262928128242493) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.15399984270334244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= -0.006225912598893046) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.028940661810338497) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0653241276741028) { + if (averageDuration_2 <= -0.03282356634736061) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.016038838773965836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.7523583173751831) { + if (averageDuration_2 <= -0.1822899580001831) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.5941142290830612) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.577582448720932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4105652570724487) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2331566214561462) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4833749979734421) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.22427384555339813) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8847585320472717) { + if (maxDuration_2 <= 0.21497700363397598) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.5408204197883606) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.797663688659668) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0970470905303955) { + if (averageDuration_2 <= 0.15577057749032974) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14785322546958923) { + if (maxDuration_2 <= 1.3022134900093079) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.039908528327942) { + if (maxDuration_2 <= -0.006436079973354936) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5058493167161942) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2870839834213257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614118337631226) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9362238049507141) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7373296320438385) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6146548986434937) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614332914352417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 0.2269914671778679) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9186708033084869) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5245692431926727) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5169532597064972) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.0585829615592957) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4988882541656494) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (averageDuration_2 <= 0.2515539079904556) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.622090995311737) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 4.785886287689209) { + if (averageDuration_2 <= 0.26195596158504486) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998889923096) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7170225083827972) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2763279676437378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= 2.5764869451522827) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.5609686970710754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.013322114944458) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.17731168866157532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 3.1995418071746826) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8508365154266357) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1653001457452774) { + if (maxDuration_2 <= 2.6575735807418823) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 3.0148682594299316) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.21122296154499054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 3.1250656843185425) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612886905670166) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5825729370117188) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (maxDuration_2 <= 2.41451358795166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0989459902048111) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9034896492958069) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.7973603010177612) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11557363718748093) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + if (maxDuration_2 <= 3.146760582923889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.817373812198639) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621612429618835) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + if (averageDuration_2 <= 0.3800201117992401) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 7.635167121887207) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7601674497127533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 5.044552564620972) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= 0.6783531904220581) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05709555000066757) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1290577054023743) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3796064853668213) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913533687592) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2673759460449219) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3187861442565918) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 4.527082920074463) { + if (averageDuration_2 <= 2.020587921142578) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (averageDuration_2 <= 2.019300699234009) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.127554178237915) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610717296600342) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1434627771377563) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.8408887684345245) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 1.8670645356178284) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.137565553188324) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738001227378845) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5320121943950653) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3421038389205933) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504844069480896) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177308797836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 1.8014256954193115) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5027788877487183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1475950479507446) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.9434726238250732) { + if (maxDuration_2 <= 1.526749312877655) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.7574002742767334) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 0.439385250210762) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2860610783100128) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12626661732792854) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.027185082435608) { + if (numMissedDeadlines_2 <= 6.5955281257629395) { + if (maxDuration_2 <= 1.2213954329490662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.8056182861328125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.360052227973938) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5203419327735901) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (maxDuration_2 <= 4.237208604812622) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0015177130699158) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 1.5044794082641602) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0916837751865387) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1346113122999668) { + if (maxDuration_2 <= 0.5957824885845184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30056197941303253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1897109746932983) { + if (maxDuration_2 <= 3.1951706409454346) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.134947121143341) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9034896492958069) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (maxDuration_2 <= 1.3252560496330261) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9406739771366119) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.749491214752197) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.743839293718338) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819011688232) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.35550594329834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461492896080017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= 2.291628837585449) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.013322114944458) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0192918479442596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.7040885090827942) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7944985032081604) { + if (maxDuration_2 <= 0.6059436202049255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6375060975551605) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2587464302778244) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.8907558917999268) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4223690927028656) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39485372602939606) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.6104344129562378) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.887678474187851) { + if (maxDuration_2 <= 1.0535055994987488) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34496691823005676) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3447071462869644) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5491238534450531) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0244272351264954) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25677254796028137) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5541929602622986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48101936280727386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613492488861084) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.00575818947982043) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18140528351068497) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.9961256682872772) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3884168863296509) { + if (averageDuration_2 <= 1.4893895983695984) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.01875431463122368) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8873403668403625) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0946863479912281) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13951494544744492) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32151108980178833) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.31480924785137177) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16625051945447922) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7504318058490753) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46158766746521) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6149652898311615) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.355647936463356) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.019662188831716776) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.011540561397850979) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22202018648386002) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.0642496682703495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0531170964241028) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9891899228096008) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39978136122226715) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5383607149124146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 1.539103388786316) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3138265907764435) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.5802874863147736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2688552141189575) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319651782512665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13596490770578384) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.025206602178514004) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20746057480573654) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7558080554008484) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.729569673538208) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643928408622742) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9349343776702881) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27657751739025116) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06669353321194649) { + if (maxDuration_2 <= 1.2695014476776123) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1706795170903206) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 3.3745003938674927) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.0145689249038696) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 1.100279450416565) { + if (averageDuration_2 <= 1.8760048747062683) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 1.2375778555870056) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.049462681636214256) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4586123377084732) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (averageDuration_2 <= 2.1512858867645264) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7137278616428375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5116468667984009) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { + if (maxDuration_2 <= 2.8213220834732056) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 2.424679160118103) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.721377968788147) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6604832112789154) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6153981983661652) { + if (averageDuration_2 <= 2.0978039503097534) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621641635894775) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601367115974426) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623468518257141) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6282088756561279) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.61161208152771) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 3.0371495485305786) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 2.887550115585327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 2.359539747238159) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482353746891022) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29653431475162506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + if (maxDuration_2 <= 1.2388759851455688) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5276185572147369) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5249494016170502) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.6485667824745178) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6514894366264343) { + if (maxDuration_2 <= 3.338495373725891) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3725270926952362) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5749098658561707) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5654532313346863) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07367156073451042) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.2469632625579834) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.27204692363739) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.399016797542572) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05094969645142555) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3293897807598114) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4892883002758026) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 5.020978689193726) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 1.8683618903160095) { + if (maxDuration_2 <= 1.8023314476013184) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4861375093460083) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3822421282529831) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.261569023132324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 6.416047811508179) { + if (averageDuration_2 <= 1.316986083984375) { + if (averageDuration_2 <= 1.2343434691429138) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4416620135307312) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2840093523263931) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { + if (maxDuration_2 <= 1.6516566276550293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7853520214557648) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.016276582384307403) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4981125742197037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.234639286994934) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.5941141843795776) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.49310925602912903) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.162411332130432) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { + if (averageDuration_2 <= 1.310598075389862) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.997084766626358) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6891340613365173) { + if (maxDuration_2 <= 0.7302684783935547) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.508066862821579) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03231922537088394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.7287690937519073) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7941327691078186) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1893460676074028) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22730766981840134) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.9108937978744507) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613355994224548) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6790977120399475) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (maxDuration_2 <= 0.9613054990768433) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5499634146690369) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0268927812576294) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6029710918664932) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15292972326278687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.4317436218261719) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4626829624176025) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (maxDuration_2 <= 2.110324501991272) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.6300016343593597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08121922239661217) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08242103457450867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26995179057121277) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23185841739177704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.802748203277588) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.724402904510498) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291577041149139) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4759628623723984) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.5129289031028748) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1400446891784668) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5579615533351898) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3244428336620331) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7074764519929886) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5714039504528046) { + if (averageDuration_2 <= 2.1093735694885254) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (maxDuration_2 <= 6.129816055297852) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3212643787264824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 6.195605754852295) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615378379821777) { + if (maxDuration_2 <= 6.9213128089904785) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9760755896568298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 7.559720993041992) { + if (averageDuration_2 <= 3.7737587690353394) { + if (averageDuration_2 <= 3.709157705307007) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34422287344932556) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.9285858571529388) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3021332025527954) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7243996858596802) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (maxDuration_2 <= 0.29267486929893494) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291517734527588) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.378357857465744) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (maxDuration_2 <= 0.1460927575826645) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.7305975258350372) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.835627019405365) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7299784421920776) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.6305077075958252) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3265749216079712) { + if (averageDuration_2 <= 0.5176114439964294) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3133423328399658) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.36834917962551117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7714039981365204) { + if (averageDuration_2 <= 0.4220243841409683) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7889449000358582) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (maxDuration_2 <= 0.5027389526367188) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.8395034074783325) { + if (maxDuration_2 <= 0.38479121029376984) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3715471029281616) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7362314164638519) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (averageDuration_2 <= 0.892030268907547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.3501546233892441) { + if (maxDuration_2 <= 0.3567013442516327) { + if (averageDuration_2 <= -0.05101020261645317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3091809153556824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (maxDuration_2 <= 0.787327378988266) { + if (averageDuration_2 <= 0.8451510369777679) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.5353574752807617) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7298338711261749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7450264692306519) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.03769860789179802) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.8056840002536774) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041784286499) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7353557646274567) { + if (maxDuration_2 <= 0.05073441565036774) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.8107065260410309) { + if (averageDuration_2 <= 0.4237384796142578) { + if (maxDuration_2 <= 0.4866992235183716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (maxDuration_2 <= 0.06992466002702713) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7915673553943634) { + if (averageDuration_2 <= 0.538516640663147) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9137649834156036) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 1.214015245437622) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (averageDuration_2 <= 0.5769166648387909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.764543205499649) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (averageDuration_2 <= 0.6553438603878021) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (maxDuration_2 <= 0.49957050383090973) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7303033471107483) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (maxDuration_2 <= 0.7126586139202118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3501206636428833) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.6066030561923981) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3385461568832397) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (maxDuration_2 <= 0.8123276233673096) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.5048055648803711) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= 1.547933042049408) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.5942425429821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (averageDuration_2 <= 0.6103363335132599) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 1.297077476978302) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7167105674743652) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 1.324093997478485) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6369636058807373) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3388392329216003) { + if (maxDuration_2 <= 0.8830580115318298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.17070535570383072) { + if (maxDuration_2 <= 0.03542421758174896) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7167170643806458) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3300318717956543) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 1.0195274949073792) { + if (maxDuration_2 <= 0.5346001088619232) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7039747536182404) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7192570865154266) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.4277103394269943) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3781013488769531) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7082774341106415) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7188273966312408) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.7527487874031067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (averageDuration_2 <= 1.6634626984596252) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3042593598365784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.7694137394428253) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7190191149711609) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.428335964679718) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.714835524559021) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6820487082004547) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + if (maxDuration_2 <= -0.006968073081225157) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870142102241516) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.5917955040931702) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (maxDuration_2 <= -0.016516088973730803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.6384455859661102) { + if (averageDuration_2 <= -0.061506884172558784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0250356197357178) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1139658093452454) { + if (maxDuration_2 <= 0.284985676407814) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2451224327087402) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486253082752228) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7283376455307007) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481821775436401) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (averageDuration_2 <= 0.06543360091745853) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.44417300820350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2644217610359192) { + if (maxDuration_2 <= 0.085449930280447) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485407888889313) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2682607173919678) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486195862293243) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1965546011924744) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.00672119262162596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7285553514957428) { + if (maxDuration_2 <= 0.20962027460336685) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8312131464481354) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (maxDuration_2 <= 0.5823515057563782) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2617387175559998) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.248332142829895) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748622864484787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.2047244906425476) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7070249021053314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5689606815576553) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.734384298324585) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.07333364337682724) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5663581192493439) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (averageDuration_2 <= 0.030110999010503292) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6790743172168732) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1662045121192932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7092773616313934) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27777573466300964) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8088094294071198) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9252032339572906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.053518569096922874) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5767443478107452) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1295673251152039) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { + if (maxDuration_2 <= 0.08950985223054886) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9589276909828186) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6793113052845001) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0632541012018919) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (averageDuration_2 <= 0.6980580389499664) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5522426068782806) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04067927086725831) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4450313597917557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.42228297889232635) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.31924521923065186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.8067479133605957) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0003452599048615) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5516719818115234) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3758608549833298) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.3809443712234497) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414793252945) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20446494966745377) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6188088357448578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18066196143627167) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20783467590808868) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2646302506327629) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.047407783567905426) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1578196287155151) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15819264948368073) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33223602175712585) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3787037134170532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (maxDuration_2 <= 0.25562411546707153) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15024030953645706) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.058333855122327805) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11745284497737885) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.005097192712128162) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.33699631690979) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.00303316116333) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.23250066488981247) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 1.1464404463768005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.21996638923883438) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.177801489830017) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.44097670912742615) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.28779345750808716) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.382149577140808) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3118772506713867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.15153032913804054) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1118956804275513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07619240134954453) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.15163606498390436) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.122046113014221) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.19655156880617142) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.781566321849823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4447983354330063) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4924338161945343) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5655569732189178) { + if (averageDuration_2 <= 0.098821971565485) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15152712166309357) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5228261053562164) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (averageDuration_2 <= 0.5458563268184662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.730016827583313) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02906990423798561) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02856963872909546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.238178312778473) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (maxDuration_2 <= 0.32679012417793274) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7204974591732025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.7477512061595917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7880737483501434) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 1.1180845499038696) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.690912663936615) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.8955870866775513) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.4177898168563843) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6933403313159943) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.5600239932537079) { + if (maxDuration_2 <= 0.4898955076932907) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (averageDuration_2 <= 0.6105079054832458) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6104522347450256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7122949957847595) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (maxDuration_2 <= 0.6768385767936707) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= 0.3958906829357147) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.7625952661037445) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2243144512176514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 1.220582902431488) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.814079612493515) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.910700649023056) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.5329816937446594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.648058295249939) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4057249426841736) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0356513261795044) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7177809476852417) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8228538036346436) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322981834412) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5269411504268646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.024478145875036716) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45097780227661133) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1932070329785347) { + if (averageDuration_2 <= 0.9761073887348175) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057841777802) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + if (averageDuration_2 <= 0.7880142033100128) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2888569235801697) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616374969482422) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591094017029) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2780311852693558) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617928862571716) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617889523506165) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.030746312346309423) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.286307215690613) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.22667479515075684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7833147644996643) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.929038792848587) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.385517880320549) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4462291747331619) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.41568124294281) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620673656463623) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.460362434387207) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3139577805995941) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1886991262435913) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (maxDuration_2 <= 0.2860620766878128) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4849824011325836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.657949298620224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6269091367721558) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.783094972372055) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1779231429100037) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819309711456) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.9102014303207397) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.22145304828882217) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.380356550216675) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.8965803384780884) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.019650638103485) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.170151710510254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351780652999878) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618065357208252) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.031726360321045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8021548986434937) { + if (averageDuration_2 <= 0.19217464327812195) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38952675461769104) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5133434683084488) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.46319472789764404) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.2990090548992157) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197498083115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3670244216918945) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.699196070432663) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (averageDuration_2 <= 0.7871937155723572) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7223055958747864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 1.5531962513923645) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (maxDuration_2 <= 0.8816423714160919) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.3247819542884827) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5729213654994965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4596960544586182) { + if (maxDuration_2 <= 0.7243494391441345) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.516703724861145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5253596305847168) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3021210432052612) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.582572817802429) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16512469202280045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.359485849738121) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10414645820856094) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0496952533721924) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3159325122833252) { + if (maxDuration_2 <= 0.44848354160785675) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (averageDuration_2 <= 0.11518798395991325) { + if (maxDuration_2 <= 0.3707425892353058) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.025949942879378796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6412768661975861) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (maxDuration_2 <= 0.707306981086731) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.71396803855896) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.09735488146543503) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7376724183559418) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.5833165347576141) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (averageDuration_2 <= 0.40346167981624603) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.1455988883972168) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3750118017196655) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7479744851589203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.3382798433303833) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8841897249221802) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (averageDuration_2 <= 0.4573909193277359) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.772458016872406) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7350341081619263) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.3439282029867172) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3177205920219421) { + if (averageDuration_2 <= 0.3965920954942703) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7781811356544495) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3947518467903137) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.1614854633808136) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7318580746650696) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (maxDuration_2 <= 0.7335355281829834) { + if (averageDuration_2 <= -0.22358045727014542) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.18644369393587112) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (averageDuration_2 <= -0.10436297208070755) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (maxDuration_2 <= 0.6476949453353882) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6370158791542053) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7460389733314514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.4726207107305527) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6254860162734985) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7479088604450226) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8777644336223602) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (averageDuration_2 <= 0.25544995069503784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.276338279247284) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482175230979919) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8190293312072754) { + if (maxDuration_2 <= 0.40889255702495575) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2160131931304932) { + if (averageDuration_2 <= 0.35561203956604004) { + if (maxDuration_2 <= 0.38028834760189056) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (averageDuration_2 <= -0.33521825075149536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (averageDuration_2 <= -0.11710859835147858) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.38294506072998047) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.43432772159576416) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (maxDuration_2 <= 0.22152647376060486) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (averageDuration_2 <= -0.32574252784252167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.44835247099399567) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7307056486606598) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.20909659564495087) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= -0.02430170215666294) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (averageDuration_2 <= -0.2258094772696495) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { + if (averageDuration_2 <= -0.16923687607049942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.661981076002121) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.22411730885505676) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8436429798603058) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (maxDuration_2 <= 0.5148426294326782) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8628608286380768) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3248445391654968) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.881703108549118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3696222305297852) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.0791362039744854) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8676047325134277) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3087275624275208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.23027871549129486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3503610491752625) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3935490250587463) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.23482635617256165) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.4805929362773895) { + if (maxDuration_2 <= 0.4179595708847046) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.04118461534380913) { + if (maxDuration_2 <= 0.5693234205245972) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (maxDuration_2 <= 0.48593440651893616) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.19561199098825455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (averageDuration_2 <= -0.10448626428842545) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.6849940121173859) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7117085158824921) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.10530847683548927) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8815761804580688) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.405566155910492) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.6052596867084503) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.4905616492033005) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.355560064315796) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + if (maxDuration_2 <= 0.5339010953903198) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.8635222911834717) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6903096735477448) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1538190245628357) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7840677797794342) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.165454089641571) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7340164184570312) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7063775658607483) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7445275783538818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.610241025686264) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5924471020698547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.188034474849701) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (maxDuration_2 <= 0.9008679687976837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7008077502250671) { + if (averageDuration_2 <= 0.2643844336271286) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (maxDuration_2 <= 0.6955349445343018) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7134893834590912) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.5578047037124634) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2662665247917175) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.22989191114902496) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5977491438388824) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7541024386882782) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.10216920077800751) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.42361027002334595) { + if (maxDuration_2 <= 0.4239722043275833) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (averageDuration_2 <= -0.5200619399547577) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (averageDuration_2 <= -0.2242160066962242) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43113580346107483) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.37682855129241943) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0460976362228394) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (maxDuration_2 <= 0.2023642659187317) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3809054344892502) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0422356091439724) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07928326725959778) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11036526411771774) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.48583483695983887) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4492810219526291) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.352176234126091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5094962418079376) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16918937116861343) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486220300197601) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7807817161083221) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.11793366447091103) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17433276772499084) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.5426415205001831) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.2160230204463005) { + if (averageDuration_2 <= -0.31468233466148376) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22359083592891693) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.05851230211555958) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3163090348243713) { + if (maxDuration_2 <= 0.05643293261528015) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8886953592300415) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.6861437559127808) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7507262825965881) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9234356880187988) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19263297319412231) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.55570387840271) { + if (maxDuration_2 <= 0.1708017811179161) { + if (averageDuration_2 <= -0.5610251128673553) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42362651228904724) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6677180528640747) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5612044632434845) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5631475150585175) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.584723174571991) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (averageDuration_2 <= -0.2889907509088516) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.233017198741436) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24158674478530884) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8876707553863525) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.528399646282196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (averageDuration_2 <= -0.49200408160686493) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2125556841492653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.29250966012477875) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20429229736328125) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7477016150951385) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5334058552980423) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6653278172016144) { + if (averageDuration_2 <= -0.4260232597589493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5648250579833984) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2818209081888199) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6487173736095428) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.2940475642681122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4196433573961258) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (maxDuration_2 <= 0.1861371099948883) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (maxDuration_2 <= 0.019673330709338188) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (maxDuration_2 <= 0.3337070345878601) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.4869145452976227) { + if (averageDuration_2 <= -0.6770841181278229) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.2920006066560745) { + if (maxDuration_2 <= 0.18673480302095413) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.540889710187912) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10507988184690475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.406888023018837) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2121511697769165) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20364166051149368) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.4976615309715271) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550786972046) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.30065111815929413) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8286776542663574) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.42319174110889435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.861069530248642) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4454152584075928) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485148012638092) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37531453371047974) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24337542802095413) { + if (maxDuration_2 <= 0.48002055287361145) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6374476552009583) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22205941379070282) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39401544630527496) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.528232216835022) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.1794498860836029) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.11389721930027008) { + if (averageDuration_2 <= -0.18236665427684784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14361665770411491) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.06844793073832989) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.2011863961815834) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3089614361524582) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19331497699022293) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (averageDuration_2 <= -0.13986914604902267) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (averageDuration_2 <= -0.1270977184176445) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (maxDuration_2 <= 0.018174038268625736) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6691918671131134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7537937164306641) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (averageDuration_2 <= -0.13090690970420837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5896276533603668) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3457433432340622) { + if (maxDuration_2 <= 0.042670199647545815) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6201915442943573) { + if (maxDuration_2 <= 0.029588956385850906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26812171190977097) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.1930236667394638) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4185460954904556) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6271812617778778) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.020114105194807053) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4369344413280487) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6647421419620514) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4181138873100281) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518837906420231) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41206733882427216) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3919961005449295) { + if (maxDuration_2 <= 0.2993737459182739) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.62191441655159) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (averageDuration_2 <= -0.0283217616379261) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5045276582241058) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6544688940048218) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.028121292591095) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5934527516365051) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (maxDuration_2 <= 0.1890699863433838) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8431459367275238) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.023522169329226017) { + if (maxDuration_2 <= 0.2123681977391243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5824819803237915) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7272729873657227) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486220300197601) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.6270053386688232) { + if (maxDuration_2 <= 0.3855106383562088) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.21966499835252762) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.13653941452503204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.3276115953922272) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (maxDuration_2 <= 0.6443189680576324) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.046361858025193214) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.01598227908834815) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.5216022729873657) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9378779828548431) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.36952340602874756) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3190089911222458) { + if (averageDuration_2 <= 0.1175558790564537) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6552557647228241) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6252796947956085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17310208082199097) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7450781762599945) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080834388733) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.44583430886268616) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3183697760105133) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19352737814188004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.24251005798578262) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15201273560523987) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15569567680358887) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8039239048957825) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.06512174010276794) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8923840522766113) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.35917940735816956) { + if (maxDuration_2 <= 0.21530620008707047) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.356185644865036) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21174664795398712) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.802529454231262) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.0760540664196014) { + if (maxDuration_2 <= 0.31688226759433746) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3448770344257355) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07749074697494507) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4011481702327728) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.212310254573822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.15889321267604828) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.04724868945777416) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (maxDuration_2 <= 0.48593683540821075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.675391674041748) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3441346138715744) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6100157201290131) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06244405545294285) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.22009800374507904) { + if (averageDuration_2 <= -0.39745883643627167) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4197363257408142) { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1875467672944069) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.46171484887599945) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14265850186347961) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692363262177) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6698351800441742) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.620763510465622) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48034273087978363) { + if (maxDuration_2 <= 0.0715835653245449) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (maxDuration_2 <= 0.012776992283761501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (averageDuration_2 <= -0.6418242454528809) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44426916539669037) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.933671712875366) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.889031320810318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5188502371311188) { + if (averageDuration_2 <= -0.8325169086456299) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.597811222076416) { + if (maxDuration_2 <= 0.1663769856095314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3882742077112198) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4628823399543762) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.6319969296455383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2213319540023804) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.787463665008545) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0509639978408813) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.41697587072849274) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6973564922809601) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.029960347339510918) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616639018058777) { + if (maxDuration_2 <= 0.06132879853248596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9125365614891052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46271812915802) { + if (maxDuration_2 <= 0.20561867207288742) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19302021712064743) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0102983713150024) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (numDurations_2 <= 8.122936725616455) { + if (averageDuration_2 <= -0.5750274062156677) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07656121999025345) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1900343298912048) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.50892436504364) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5622147917747498) { + if (maxDuration_2 <= 0.19127612560987473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.154384046792984) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4577379822731018) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6384816765785217) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.347765564918518) { + if (maxDuration_2 <= 0.08196248486638069) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.0907738097012043) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4899015426635742) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6776856184005737) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.15501796454191208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.17161481082439423) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9723939001560211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6053559482097626) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8988293707370758) { + if (averageDuration_2 <= -0.2605019360780716) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.12344541028141975) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.539192795753479) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18220101296901703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (averageDuration_2 <= 0.09229308366775513) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3340485244989395) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2049425840377808) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.11059711873531342) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.15582146495580673) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1814829558134079) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.08851968124508858) { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.1939581111073494) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485889792442322) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335296094417572) { + if (averageDuration_2 <= -0.004776094370754436) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142840951681) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926392555237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (averageDuration_2 <= -0.010463987477123737) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (averageDuration_2 <= -0.23142240941524506) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (averageDuration_2 <= -0.1066918708384037) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.013304732274264097) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + if (averageDuration_2 <= -0.16805126518011093) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0628843903541565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7221470475196838) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.33063115179538727) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.086323320865631) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1928851455450058) { + if (averageDuration_2 <= -0.17536146938800812) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0436993483453989) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.661136656999588) { + if (averageDuration_2 <= -0.23615023493766785) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.0335981510579586) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5396402776241302) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.30496281385421753) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621602296829224) { + if (maxDuration_2 <= 0.020542078651487827) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5013982802629471) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6005529761314392) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560848295688629) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5370949804782867) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45300357043743134) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.18895867466926575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34293997287750244) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08552069030702114) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795315980911) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37234041281044483) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03144307155162096) { + if (maxDuration_2 <= 0.0597076490521431) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08216270059347153) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (averageDuration_2 <= -0.10221527144312859) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23112794011831284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2424963042140007) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.031810143031179905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616052508354187) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.28017035126686096) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5334944427013397) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42429259419441223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11888782680034637) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46158766746521) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2470339685678482) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5389856398105621) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4483988285064697) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (averageDuration_2 <= -0.3184443265199661) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3612722158432007) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15628795325756073) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (maxDuration_2 <= 0.12875136733055115) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.465725600719452) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.027400558814406395) { + if (maxDuration_2 <= -0.011281084269285202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= 0.012500862590968609) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6191794276237488) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6222433745861053) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (averageDuration_2 <= -0.2793334722518921) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04933263547718525) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49071481823921204) { + if (averageDuration_2 <= -0.09476756677031517) { + if (averageDuration_2 <= -0.11289915442466736) { + if (maxDuration_2 <= -0.01811185199767351) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.33371785283088684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26727765798568726) { + if (numDurations_2 <= 0.439385250210762) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7961263060569763) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.466281533241272) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.129709839820862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (maxDuration_2 <= 0.12367341294884682) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.07971153035759926) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4450399875640869) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.47418642044067383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9398446679115295) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8647918701171875) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.09823410212993622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.007838984485715628) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4149242043495178) { + if (averageDuration_2 <= -0.2525296211242676) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.012821516953408718) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37432676553726196) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.953914225101471) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627880573273) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2037067413330078) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2499517798423767) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.392783522605896) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + if (averageDuration_2 <= 0.03958638198673725) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4028155654668808) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4014365077018738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.675937294960022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32650475203990936) { + if (maxDuration_2 <= 0.4944039434194565) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862634658813) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.805366575717926) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.5634624361991882) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5557366609573364) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0224738121032715) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9391517043113708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.9914973974227905) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5415807664394379) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.061789870262146) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580029129981995) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21383938938379288) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8347486853599548) { + if (maxDuration_2 <= 0.33199237287044525) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3509410172700882) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341555535793304) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.062060766853392124) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.585026204586029) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.19759371131658554) { + if (maxDuration_2 <= 0.3736323416233063) { + if (maxDuration_2 <= 0.3646717220544815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0596327185630798) { + if (averageDuration_2 <= 0.5192143619060516) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.62141352891922) { + if (averageDuration_2 <= 0.03331002208869904) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10090456902980804) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.46122559905052185) { + if (averageDuration_2 <= 9.826594032347202e-05) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { + if (maxDuration_2 <= 0.3871721923351288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5048755556344986) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6239155530929565) { + if (averageDuration_2 <= -0.16944565623998642) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.8017890453338623) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.031021786853671074) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14722063392400742) { + if (averageDuration_2 <= -0.5394869148731232) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7156547605991364) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.308888018131256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.13941966742277145) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.0809937715530396) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.5989913046360016) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (averageDuration_2 <= -0.3669191747903824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3759192228317261) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.13671940565109253) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.9914973974227905) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6395457684993744) { + if (averageDuration_2 <= 0.05797412618994713) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07076146081089973) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.3864171952009201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.06816822290420532) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3176411986351013) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.7096243500709534) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22129100561141968) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2785116583108902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.04537664353847504) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38049250841140747) { + if (averageDuration_2 <= -0.33585256338119507) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.29331816732883453) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.06767088919878006) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3649323731660843) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7112196683883667) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06686148978769779) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16349100321531296) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (maxDuration_2 <= 0.3998432457447052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22290639579296112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.4449331909418106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4779637455940247) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.24680515378713608) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.5888555347919464) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5462443828582764) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5530214309692383) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.3146580904722214) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0318717956542969) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.1039646752178669) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.4881414920091629) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2536149173974991) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.6127548217773438) { + if (averageDuration_2 <= -0.7499710917472839) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.3811798691749573) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4546968638896942) { + if (averageDuration_2 <= -0.019667698070406914) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619647860527039) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.41725030541419983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13962948322296143) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.286426067352295) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + if (maxDuration_2 <= 0.6470237970352173) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40705400705337524) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5549438744783401) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620205163955688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6365022361278534) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.3078770190477371) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462527573108673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7406275272369385) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33277831971645355) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (averageDuration_2 <= -0.049672285094857216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41269639134407043) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.19533181935548782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623185396194458) { + if (averageDuration_2 <= -0.06643534451723099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.0005051215412095189) { + if (averageDuration_2 <= -0.12774206697940826) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.6900644302368164) { + if (numDurations_2 <= 1.5776891708374023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8038868010044098) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6085982918739319) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27833783626556396) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.11755884811282158) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44290691614151) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9594480991363525) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29277460277080536) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.36024706065654755) { + if (maxDuration_2 <= 0.2841472625732422) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7421627342700958) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4433463215827942) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3235849142074585) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.020337074995041) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5741706788539886) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.36193178594112396) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1692101955413818) { + if (averageDuration_2 <= -0.23646488785743713) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7322489023208618) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06666266918182373) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4434637427330017) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.09044719114899635) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.3182220757007599) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612554907798767) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.0768701396882534) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2368706464767456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2656935304403305) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27072834968566895) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.031911457888782024) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04981585964560509) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2395479381084442) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1345600076019764) { + if (maxDuration_2 <= 0.28496788442134857) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8463237583637238) { + if (averageDuration_2 <= -0.1146455891430378) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5720092058181763) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37376396358013153) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7290521264076233) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.5594106465578079) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.16038391180336475) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34959374368190765) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4358084797859192) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.4705762565135956) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.2977922409772873) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149006992578506) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.6335321068763733) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.667253613471985) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4268258810043335) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2672328352928162) { + if (maxDuration_2 <= 1.2397143244743347) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2908948063850403) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (averageDuration_2 <= -0.1147768460214138) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6963140666484833) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7137441039085388) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7367220520973206) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8951284289360046) { + if (maxDuration_2 <= 1.0347838997840881) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (averageDuration_2 <= 0.4940515458583832) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.0273380875587463) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6439265310764313) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (averageDuration_2 <= 0.8747955858707428) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.333996832370758) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (numDurations_2 <= 2.7159931659698486) { + if (averageDuration_2 <= 0.058744143694639206) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7248106896877289) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.0508134961128235) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3808841109275818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (maxDuration_2 <= 0.9993820488452911) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.2154080867767334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 2.0939146280288696) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3406645059585571) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.1494845747947693) { + if (averageDuration_2 <= 1.6962002515792847) { + if (averageDuration_2 <= 1.2984217405319214) { + if (averageDuration_2 <= 0.8297915756702423) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8542903363704681) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7063393294811249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7245881259441376) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3326250314712524) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3316137790679932) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7211807370185852) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6782130897045135) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (maxDuration_2 <= 1.1487780213356018) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (averageDuration_2 <= 0.7705576121807098) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7301165461540222) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.698575496673584) { + if (maxDuration_2 <= 0.9817012250423431) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7657250165939331) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.0006634891033173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.997178465127945) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7803223729133606) { + if (averageDuration_2 <= 0.4392378032207489) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7227019965648651) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { + if (averageDuration_2 <= 1.17425936460495) { + if (averageDuration_2 <= -0.4650510251522064) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8465102016925812) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8867943286895752) { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7353781759738922) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 1.3574286699295044) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + if (averageDuration_2 <= 0.08344195038080215) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.06531268544495106) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8196530342102051) { + if (averageDuration_2 <= 2.228592276573181) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (maxDuration_2 <= 3.127223253250122) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5881697237491608) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (maxDuration_2 <= 4.750869274139404) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.4013153910636902) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2699247002601624) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 4.555438995361328) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15159282833337784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1527207493782043) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7358740270137787) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.320826455950737) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2158499956130981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { + if (averageDuration_2 <= 0.3709491342306137) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (averageDuration_2 <= 0.34653453528881073) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.08240407705307) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12969237938523293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2014800310134888) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.259523630142212) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 0.15480925142765045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4981125742197037) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1574791073799133) { + if (maxDuration_2 <= 1.435587465763092) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9154582917690277) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.0432456731796265) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3449762463569641) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (maxDuration_2 <= 1.4485169649124146) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6885486245155334) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6886526048183441) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2565064430236816) { + if (maxDuration_2 <= 0.9501186609268188) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6380338668823242) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.17278318852186203) { + if (averageDuration_2 <= -0.17343050986528397) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1427316665649414) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.08230776339769363) { + if (averageDuration_2 <= -0.08253948763012886) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 9.801794052124023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6280999481678009) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5406005382537842) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.18271947279572487) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 1.3693780303001404) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2194320559501648) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701804161072) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5723515450954437) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23277811706066132) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396028995514) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485400140285492) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461732268333435) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0973148345947266) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 1.2440527081489563) { + if (averageDuration_2 <= 1.73860764503479) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.3084317445755005) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 1.0621952414512634) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233769893646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2889532446861267) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5404995977878571) { + if (averageDuration_2 <= 0.03363163024187088) { + if (maxDuration_2 <= 5.442666530609131) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17533350735902786) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.019098293036222458) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15313415229320526) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7273778319358826) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0403966903686523) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.33660896122455597) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24161361157894135) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12640953436493874) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.18711814284324646) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1658167615532875) { + if (numDurations_2 <= -0.12976674735546112) { + if (maxDuration_2 <= 1.0377017259597778) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.4347721934318542) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.437980055809021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.114682912826538) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28755907714366913) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.9720517694950104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.009847766952589154) { + if (maxDuration_2 <= 0.9507694244384766) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.0623169541358948) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3506556302309036) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.667253613471985) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06506203301250935) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13083729892969131) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05861735716462135) { + if (averageDuration_2 <= 1.2439587712287903) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 4.728882312774658) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 8.271708488464355) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08376500755548477) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07696647383272648) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 4.234511375427246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 1.9694133400917053) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9057248532772064) { + if (averageDuration_2 <= -0.34881260991096497) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (maxDuration_2 <= 1.0196890830993652) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0258170664310455) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.047807216644287) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4246694892644882) { + if (averageDuration_2 <= -0.03377376776188612) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.42365574836730957) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2641832232475281) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.654310792684555) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 0.4608350396156311) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1218477338552475) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.4003121852874756) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17989181727170944) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0923520177602768) { + if (maxDuration_2 <= 7.748300313949585) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { + if (maxDuration_2 <= 5.502759695053101) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2760445326566696) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940382003784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19346007704734802) { + if (averageDuration_2 <= 3.581660270690918) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.495326966047287) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 5.497339487075806) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3789841532707214) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21568135917186737) { + if (maxDuration_2 <= 4.041155576705933) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5587422549724579) { + if (averageDuration_2 <= 1.8233594298362732) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5767306089401245) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306547224521637) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5069313049316406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5490114688873291) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0255975890904665) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09108610451221466) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738001227378845) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6598487496376038) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6908779740333557) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20580721646547318) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1277656927704811) { + if (averageDuration_2 <= -0.042279867455363274) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49306267499923706) { + if (averageDuration_2 <= -0.5489812791347504) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07994036376476288) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4251624047756195) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5092168748378754) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6228834390640259) { + if (maxDuration_2 <= 2.3995301723480225) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27492596209049225) { + if (averageDuration_2 <= 0.7995809614658356) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36848193407058716) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + if (averageDuration_2 <= 0.2559853494167328) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 2.031608462333679) { + if (averageDuration_2 <= -0.31484147906303406) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7692394852638245) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.493299663066864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4393751323223114) { + if (maxDuration_2 <= 1.1987935900688171) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5402822196483612) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.03565223515033722) { + if (maxDuration_2 <= 1.4213740825653076) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5703529417514801) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.1997610926628113) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.46887846291065216) { + if (maxDuration_2 <= 4.473825454711914) { + if (maxDuration_2 <= 3.26335072517395) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7360367178916931) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4981432259082794) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.01875431463122368) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 3.676967144012451) { + if (averageDuration_2 <= -0.0972072146832943) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6087082922458649) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 3.9335360527038574) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1530905961990356) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1843433827161789) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.5372523665428162) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 2.2581138610839844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7942191362380981) { + if (maxDuration_2 <= 1.1155110597610474) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (averageDuration_2 <= -0.27747705578804016) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (averageDuration_2 <= 0.038410043343901634) { + if (maxDuration_2 <= 0.9718669950962067) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49339374899864197) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3192542940378189) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9059016704559326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22025777399539948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618202447891235) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3625665605068207) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.595767855644226) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5629400014877319) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855878829956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2197190597653389) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6394426822662354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40631960332393646) { + if (averageDuration_2 <= -0.05224973149597645) { + if (numDurations_2 <= 6.700057029724121) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (maxDuration_2 <= 1.7121778726577759) { + if (maxDuration_2 <= 1.5087089538574219) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.9304614961147308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.2522764205932617) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.28313285112381) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.39119021594524384) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 0.3465253859758377) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473682403564) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7422017455101013) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3615803718566895) { + if (averageDuration_2 <= 0.8954007923603058) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.603843688964844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7825998663902283) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.711048424243927) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7480331063270569) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 4.056646347045898) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 4.231687545776367) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2032031416893005) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.586751937866211) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -3.035153388977051) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numMissedDeadlines_2 <= 4.563007950782776) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.463899254798889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2526502013206482) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.982878804206848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8448909521102905) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (averageDuration_2 <= 1.3239935636520386) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.498723864555359) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (maxDuration_2 <= 4.87779974937439) { + if (maxDuration_2 <= 2.3121676445007324) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.1321862936019897) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7348887622356415) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4935392141342163) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.454002380371094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4438839554786682) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9139221906661987) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 0.9661585986614227) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.16788558661937714) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6907860934734344) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504844069480896) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1833787560462952) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.448194146156311) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.746365487575531) { + if (maxDuration_2 <= 0.9847912192344666) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620584785938263) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.234639286994934) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.4668562412261963) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.2249562740325928) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.6445416212081909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623048305511475) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4457237720489502) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.833759069442749) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7582613229751587) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.36838899552822113) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11492381989955902) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660343885422) { + if (averageDuration_2 <= 0.7805143892765045) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4246906116604805) { + if (maxDuration_2 <= 1.2258046865463257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815161705017) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.5529089570045471) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.3759522885084152) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7460162043571472) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (maxDuration_2 <= 4.934912204742432) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8281188905239105) { + if (averageDuration_2 <= 0.7098559141159058) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.573121190071106) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.157832622528076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 8.277822494506836) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.437980055809021) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.6682068407535553) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12303692102432251) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.349606215953827) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.953968048095703) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.337915778160095) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.21181511133909225) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.2224787175655365) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6447762846946716) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.5744774341583252) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5361003279685974) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 2.1362669467926025) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.743943840265274) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + if (maxDuration_2 <= 0.22033867985010147) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.188845932483673) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.421170234680176) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4157383292913437) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.404264450073242) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.008243268355727196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2251909971237183) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.06882278993725777) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.5053845942020416) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.63319993019104) { + if (maxDuration_2 <= 0.9504174888134003) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7926430106163025) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.7295695543289185) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.027185082435608) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.5034048110246658) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.5008799582719803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.415175676345825) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (maxDuration_2 <= 0.2468533217906952) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.265189170837402) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.429135799407959) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2464916706085205) { + if (maxDuration_2 <= 0.40787170827388763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5502367317676544) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.0754135847091675) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.437940537929535) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748391330242157) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (maxDuration_2 <= 0.38711637258529663) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.58152174949646) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (maxDuration_2 <= 0.0807366743683815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6072250306606293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { + if (averageDuration_2 <= -0.03426414728164673) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9295657873153687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4365596771240234) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (averageDuration_2 <= 0.354840487241745) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.1415839195251465) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8322991132736206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5589273571968079) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9236379861831665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.1826794594526291) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.2103766202926636) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.22172657400369644) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.399782419204712) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8780616521835327) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.9040824174880981) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9639345407485962) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 0.43938523530960083) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.444998502731323) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 0.24819854646921158) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618651270866394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.3048789501190186) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17757216095924377) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7354914247989655) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7386195361614227) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615622758865356) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (averageDuration_2 <= -0.18567488342523575) { + if (maxDuration_2 <= 0.3714416176080704) { + if (averageDuration_2 <= -0.42423610389232635) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (maxDuration_2 <= 1.869640290737152) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.111296832561493) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.735918045043945) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + if (numDurations_2 <= 1.008537232875824) { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.059429883956909) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.277944803237915) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { + if (averageDuration_2 <= 0.8997042775154114) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615329504013062) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { + if (averageDuration_2 <= -0.406320720911026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5075617134571075) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623331427574158) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (averageDuration_2 <= 0.15022411197423935) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0674490332603455) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7263267040252686) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.3761270195245743) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.381176233291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.677203357219696) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.112101793289185) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.5855295658111572) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6061519682407379) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.18354304879903793) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + if (averageDuration_2 <= -0.5602931082248688) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37562336027622223) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7782952785491943) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.02038021106272936) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0900914072990417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8438576757907867) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2226265668869019) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3992462754249573) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.0406333208084106) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619892239570618) { + if (maxDuration_2 <= 0.09245289117097855) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.051824569702148) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (averageDuration_2 <= -0.5625777542591095) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9638757109642029) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616668224334717) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8729664087295532) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.2630579322576523) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.1715557873249054) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40520548820495605) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (averageDuration_2 <= -0.42834365367889404) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.316119909286499) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9126373529434204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6286241710186005) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612310528755188) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0664097368717194) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7346532046794891) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (maxDuration_2 <= 5.134118556976318) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.0849900245666504) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3955165594816208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 2.913347601890564) { + if (averageDuration_2 <= 1.18455171585083) { + if (maxDuration_2 <= 2.27710497379303) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8780616521835327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6035331785678864) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.2615691423416138) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1853603571653366) { + if (averageDuration_2 <= 1.6916465163230896) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16008039563894272) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4590892791748047) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 4.585613012313843) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0654605627059937) { + if (maxDuration_2 <= 4.9905173778533936) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6866998672485352) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5427366495132446) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.5524985790252686) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.558120250701904) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.853458523750305) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.11852159723639488) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (maxDuration_2 <= 2.418796420097351) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7348887622356415) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.1251208782196045) { + if (maxDuration_2 <= 2.733711361885071) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.0849900245666504) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.9133753776550293) { + if (averageDuration_2 <= 0.8541741371154785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.099122047424316) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.17506881058216095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 4.443344593048096) { + if (averageDuration_2 <= 0.09622830152511597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294076919556) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.6967872381210327) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3601619005203247) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1672489643096924) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2132534384727478) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7079232633113861) { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.783979892730713) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.5427379608154297) { + if (numDurations_2 <= 1.008537232875824) { + if (averageDuration_2 <= 0.8650996685028076) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5710693895816803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.09397531673312187) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.139175176620483) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.134758949279785) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_7_2 <= -5.560335159301758) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -5.542833089828491) { + if (maxDuration_2 <= 1.4604384303092957) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.0674948692321777) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1562999486923218) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.9340291023254395) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1277238726615906) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6476744413375854) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9789374470710754) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601836204528809) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.99435293674469) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.586751937866211) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.982967972755432) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0982938408851624) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -5.837942838668823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.454709768295288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.43490731716156) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8912922143936157) { + if (averageDuration_2 <= -0.44667379558086395) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.2391209974884987) { + if (averageDuration_2 <= -0.28988786041736603) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.111681342124939) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616658091545105) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.7575366497039795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.735918045043945) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.0422221422195435) { + if (averageDuration_2 <= -0.5562194883823395) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.3491384983062744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.6747801303863525) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3431223630905151) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.3855801820755005) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.691397488117218) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.2226991280913353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.2219114899635315) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4300630688667297) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { + if (averageDuration_2 <= -0.563870757818222) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1844987869262695) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.2055274099111557) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4490292072296143) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4546351432800293) { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= 0.18363483995199203) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.346752107143402) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.6636706292629242) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.4826260060071945) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.430952250957489) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.893477201461792) { + if (maxDuration_2 <= 0.1935705617070198) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.6307660341262817) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.205713987350464) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0897412300109863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.851856768131256) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7210044860839844) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2661662846803665) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.6307660341262817) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.4424600750207901) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7706212997436523) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0725500583648682) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5387277007102966) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.2534535229206085) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.1251208782196045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8025574684143066) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2577635645866394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.0585830211639404) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.092849254608154) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.700800359249115) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.308637857437134) { + if (maxDuration_2 <= 0.6613157987594604) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.812397599220276) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.3486677557229996) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2447715997695923) { + if (maxDuration_2 <= 0.3762309104204178) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.011162791401147842) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9528200030326843) { + if (averageDuration_2 <= -0.39246559143066406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.97426438331604) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6184161007404327) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812395572662354) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.987226366996765) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.132140636444092) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.791597366333008) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616882801055908) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.38967615365982056) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (maxDuration_2 <= 0.4418680667877197) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.180942177772522) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + if (maxDuration_2 <= 1.2404944896697998) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.8101627826690674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.9373741149902344) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8274345993995667) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.7604022324085236) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5652191638946533) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6628259122371674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1879565715789795) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.5731871128082275) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.1894078552722931) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { + if (maxDuration_2 <= 1.231391727924347) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.69642436504364) { + if (maxDuration_2 <= 0.6272156238555908) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19283422827720642) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.7453612089157104) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8612625002861023) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4122499227523804) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5842567980289459) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 2.420959234237671) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.487790107727051) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.34082792699337006) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.21765905618667603) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.732524633407593) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953776597976685) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.545638561248779) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118146881461143) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8869194984436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.0929903388023376) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.00006628036499) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.7182124853134155) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6326003074645996) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.84874153137207) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -5.332040548324585) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5505964756011963) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7907134294509888) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { + if (maxDuration_2 <= 0.31979501247406006) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715816631913185) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5486325025558472) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1475950479507446) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.044032835867255926) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.23920727521181107) { + if (averageDuration_2 <= -0.5157760679721832) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.940490186214447) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.5613828897476196) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5878564715385437) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.463899254798889) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.749365210533142) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + if (maxDuration_2 <= 0.5469192564487457) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0677136182785034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9617350101470947) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.592329502105713) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07367007434368134) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.2198650985956192) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.0538922548294067) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4596344828605652) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2987598180770874) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.15305794775485992) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4840766191482544) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8952721953392029) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9559153914451599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.11118209734559059) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.6843383312225342) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616599678993225) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5258576273918152) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.542178750038147) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3647471070289612) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.015125670470297337) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5509052872657776) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5676898658275604) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06513400934636593) { + if (maxDuration_2 <= 0.49818260967731476) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5213649570941925) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14346570521593094) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (averageDuration_2 <= -0.4903840124607086) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5562154948711395) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0082823038101196) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153710365295) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0046014785766602) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6019871830940247) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.191977858543396) { + if (maxDuration_2 <= 0.750056266784668) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.287364959716797) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23392348736524582) { + if (numDurations_2 <= 1.8622652292251587) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841270714998245) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (averageDuration_2 <= -0.1397009715437889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { + if (averageDuration_2 <= -0.4706839770078659) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2249875664710999) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.442241072654724) { + if (averageDuration_2 <= -0.4147425442934036) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (maxDuration_2 <= 0.31923268735408783) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9304579496383667) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6949154138565063) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.0243793725967407) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606691598892212) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.697882056236267) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.171576499938965) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5115883648395538) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2634060978889465) { + if (maxDuration_2 <= 0.2689714729785919) { + if (averageDuration_2 <= -0.8843685388565063) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.0049888622015714645) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5653403401374817) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3740711212158203) { + if (maxDuration_2 <= -0.020862341858446598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.781872272491455) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.476829707622528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8633034825325012) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12482808530330658) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9362237751483917) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.190671145915985) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9096425473690033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236781001091003) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9985226392745972) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06469383370131254) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8125279545783997) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.6519380807876587) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0108682513237) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4517258405685425) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.4151755571365356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1908841133117676) { + if (averageDuration_2 <= -0.290820837020874) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9762081205844879) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34099067747592926) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08570989221334457) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7601674497127533) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.18297383189201355) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8002705574035645) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9433919489383698) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22526995837688446) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09513238444924355) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4736533761024475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998483300209) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + if (averageDuration_2 <= -0.402012899518013) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8773755729198456) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6297035217285156) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6389772891998291) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1864543855190277) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9282219707965851) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2433997169137001) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0222047567367554) { + if (averageDuration_2 <= -0.23228415846824646) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (averageDuration_2 <= -0.23616617172956467) { + if (maxDuration_2 <= 0.10271772742271423) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5344285368919373) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24685662984848022) { + if (averageDuration_2 <= -0.15420926362276077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.09499573335051537) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5047082901000977) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9299096465110779) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 0.0377645269036293) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1265933513641357) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0370712280273438) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1459269067272544) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.127111554145813) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (maxDuration_2 <= 1.426781415939331) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0279250144958496) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31352490186691284) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (averageDuration_2 <= -0.14483404904603958) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (maxDuration_2 <= -0.00603093346580863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.649102509021759) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8230292797088623) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= 4.5160605907440186) { + if (averageDuration_2 <= -0.18871399015188217) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09280875325202942) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (maxDuration_2 <= 0.45623114705085754) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (maxDuration_2 <= 0.86497962474823) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (maxDuration_2 <= 2.9899936635047197e-05) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 2.346733570098877) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9327906668186188) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.437747836112976) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.22203048318624496) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4797641038894653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3616790473461151) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7634464502334595) { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.22944680601358414) { + if (averageDuration_2 <= -0.5647774934768677) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (maxDuration_2 <= 0.27496108412742615) { + if (averageDuration_2 <= -0.7766503691673279) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.273658037185669) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.6456998586654663) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8087291717529297) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.130564846098423) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (averageDuration_2 <= -0.6203295588493347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4296009540557861) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.9608718156814575) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5586740374565125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.673958957195282) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4662640690803528) { + if (averageDuration_2 <= -0.7149122953414917) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0276674628257751) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5010069161653519) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12180086597800255) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30836057662963867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.498723864555359) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.286965489387512) { + if (maxDuration_2 <= 0.20517290383577347) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.429601788520813) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 0.21993084251880646) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2757284343242645) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7175521850585938) { + if (averageDuration_2 <= -0.4478025734424591) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08609193190932274) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9801180064678192) { + if (maxDuration_2 <= 0.20576544106006622) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.27050212025642395) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9907727837562561) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49218109250068665) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.023329058662056923) { + if (maxDuration_2 <= 0.005171212833374739) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5624487698078156) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12173149362206459) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.068531036376953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (averageDuration_2 <= -0.45919619500637054) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.24256665259599686) { + if (averageDuration_2 <= -0.2513412684202194) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (averageDuration_2 <= -0.2871234118938446) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9208987355232239) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7167382836341858) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8536417782306671) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533635139465332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (averageDuration_2 <= -0.45020875334739685) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.978029489517212) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20400115102529526) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= -0.026446903124451637) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.453211784362793) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4851459264755249) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02546230424195528) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3351811021566391) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4413036108016968) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6801090836524963) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4427045583724976) { + if (averageDuration_2 <= -0.43924054503440857) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6046839654445648) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3898805379867554) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3439762592315674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.48541775345802307) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4579831957817078) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4487749934196472) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (maxDuration_2 <= 0.0820510983467102) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4503461122512817) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.590840458869934) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.4310784637928009) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9625294208526611) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9650612771511078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.778005599975586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7944058179855347) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.175323273986578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3809148669242859) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.165417432785034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5461384654045105) { + if (maxDuration_2 <= -0.015895698219537735) { + if (maxDuration_2 <= -0.02159938123077154) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.856436848640442) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613434076309204) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9753895998001099) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27530206739902496) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0297358930110931) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.145269215106964) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.26463083922863007) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.3852008581161499) { + if (maxDuration_2 <= 0.015881985425949097) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.758753776550293) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.9518231749534607) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.536037802696228) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.764528274536133) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.644805073738098) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35234886407852173) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.2808487117290497) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5306718051433563) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6811587810516357) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539397239685) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { + if (averageDuration_2 <= -0.3409472405910492) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17054980993270874) { + if (averageDuration_2 <= -0.2976961135864258) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5028862357139587) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (maxDuration_2 <= 0.3221554160118103) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21358665823936462) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7382974028587341) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.5886342525482178) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2081451416015625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12936347723007202) { + if (maxDuration_2 <= 1.2196782231330872) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8826817870140076) { + if (maxDuration_2 <= 2.057348370552063) { + if (averageDuration_2 <= -0.49007444083690643) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991199404001) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7363757789134979) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4977322518825531) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9319745302200317) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1469665989279747) { + if (maxDuration_2 <= 0.41644999384880066) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010436534881592) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.77295982837677) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.2966272830963135) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33789683878421783) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6208008527755737) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (maxDuration_2 <= 0.38140007853507996) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.4863224625587463) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4474046975374222) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (averageDuration_2 <= -0.15581195056438446) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31643857061862946) { + if (maxDuration_2 <= 0.34870821237564087) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (maxDuration_2 <= 0.006683351006358862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.052487095817923546) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2628925144672394) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.6909483075141907) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 1.6752436757087708) { + if (maxDuration_2 <= 0.22546987980604172) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3362553715705872) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025970578193665) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.1234295442700386) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.87017160654068) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5766326189041138) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8073097467422485) { + if (averageDuration_2 <= -0.16431204974651337) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.75286203622818) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (maxDuration_2 <= 0.20425356179475784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.056215286254883) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0241283178329468) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (maxDuration_2 <= 0.01601620903238654) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (averageDuration_2 <= -0.11832256615161896) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6461236774921417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.11668123304843903) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (maxDuration_2 <= 0.22366664558649063) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0980674028396606) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.21719423681497574) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06051773577928543) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0903100967407227) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619384407997131) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2737065404653549) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23303381353616714) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.8750420808792114) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5082814395427704) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.4770658016204834) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5281223058700562) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.12008029595017433) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461566150188446) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607601165771484) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0913562998175621) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9417820572853088) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2705117464065552) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3639540523290634) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9450945854187012) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.3708546161651611) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.1820899248123169) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5740392208099365) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461487054824829) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622735977172852) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 3.166913390159607) { + if (averageDuration_2 <= -0.22675766050815582) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (averageDuration_2 <= -0.44040344655513763) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32115907967090607) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03816409781575203) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (maxDuration_2 <= 0.013002348132431507) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7576094269752502) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.5923580229282379) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0903671532869339) { + if (maxDuration_2 <= 0.0044747485080733895) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5793808698654175) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.5861683487892151) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8475130796432495) { + if (averageDuration_2 <= -0.4562068432569504) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.13177035003900528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7348887473344803) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953776597976685) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.610603392124176) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07135216146707535) { + if (averageDuration_2 <= -0.5367028415203094) { + if (maxDuration_2 <= 0.24522492289543152) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.5694423615932465) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44010692834854126) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (maxDuration_2 <= 0.1441781222820282) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.47702690958976746) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09448360279202461) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.22408954054117203) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.8208415508270264) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.142661690711975) { + if (numDurations_2 <= 4.992600917816162) { + if (averageDuration_2 <= -0.6455116271972656) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6802394390106201) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.6878583431243896) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09055475145578384) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3481873869895935) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.5762049853801727) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5522465109825134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461240828037262) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9215435981750488) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.91382372379303) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580028533935547) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.379005551338196) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.302121102809906) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0402230620384216) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.4106956720352173) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.6712300181388855) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2493237257003784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.6858617663383484) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.215156376361847) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.702205240726471) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.7625550329685211) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.048900008201599) { + if (maxDuration_2 <= 0.36165015399456024) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1025575399398804) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8434191346168518) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33148643374443054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5400580763816833) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.4613364189863205) { + if (averageDuration_2 <= -0.5624776482582092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5705105066299438) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6971102356910706) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.452039897441864) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 7.269208669662476) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.985676348209381) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9450717270374298) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4659591317176819) { + if (averageDuration_2 <= -0.6260405778884888) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1279932260513306) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.263444185256958) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9643280804157257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.0422221422195435) { + if (averageDuration_2 <= -0.7380890250205994) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.2544466033577919) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.629876583814621) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6267067193984985) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.048900008201599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.6689746677875519) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.130414366722107) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.557671844959259) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.17258320748806) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (maxDuration_2 <= 0.25258977711200714) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2148807048797607) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.611809015274048) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5296339988708496) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.292544662952423) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.998237282037735) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11693140491843224) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.3092772364616394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (averageDuration_2 <= -0.2714572548866272) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7607354819774628) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5340162217617035) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.075546741485596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.4010125398635864) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1280596256256104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.679324150085449) { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.446711540222168) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5062246322631836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.9133753776550293) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05649562552571297) { + if (maxDuration_2 <= 0.8136114478111267) { + if (maxDuration_2 <= 0.07544586062431335) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5781428217887878) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { + if (maxDuration_2 <= 0.19446707516908646) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8818207383155823) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.32224899530410767) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002657651901245) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 2.1921916007995605) { + if (averageDuration_2 <= -0.3642892390489578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 1.3434457182884216) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.242711365222931) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1290903091430664) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1047318577766418) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + if (averageDuration_2 <= -0.2931518107652664) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461348295211792) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5136006474494934) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.71760094165802) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.21279997378587723) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14037324488162994) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6354797780513763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.2524218484759331) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1320648193359375) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (numDurations_2 <= 7.269208908081055) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.593853771686554) { + if (maxDuration_2 <= 0.05835269205272198) { + if (averageDuration_2 <= -0.19413460791110992) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.767752766609192) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.09302541613578796) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4075369834899902) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (maxDuration_2 <= 0.08447499200701714) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1780346632003784) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2288076281547546) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.575429320335388) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.223210871219635) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8546578884124756) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + if (maxDuration_2 <= 1.300899088382721) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47516460716724396) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + if (averageDuration_2 <= -0.13573668897151947) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06185682862997055) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1074347235262394) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (averageDuration_2 <= -0.10972913727164268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (averageDuration_2 <= -0.1314106062054634) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.161266565322876) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.2927685081958771) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.16774874180555344) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.003833495080471039) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.47503624856472015) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620584785938263) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14366307854652405) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1166411638259888) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5400350093841553) { + if (maxDuration_2 <= 0.5393617451190948) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05858609080314636) { + if (averageDuration_2 <= -0.38487212359905243) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.21749939769506454) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (averageDuration_2 <= -0.16139937937259674) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24401267617940903) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.712962806224823) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.027522695250809193) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1084095872938633) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { + if (averageDuration_2 <= -0.6417401134967804) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4900496304035187) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + if (maxDuration_2 <= 0.0650872066617012) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11292750015854836) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.016777722164988518) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5211844444274902) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5151720345020294) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.5771467983722687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.2386099100112915) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7585369348526) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 1.7950525283813477) { + if (maxDuration_2 <= 1.2090941071510315) { + if (averageDuration_2 <= -0.4267774075269699) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12311100959777832) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.730594277381897) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.4565378576517105) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.18880262970924377) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32594868540763855) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (maxDuration_2 <= 2.19901442527771) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768269538879) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9328323006629944) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5486069321632385) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47346721589565277) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 1.270185112953186) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0005955866508884355) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.24561848491430283) { + if (averageDuration_2 <= -0.5162278413772583) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.7564848363399506) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (maxDuration_2 <= 0.20683931559324265) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.331565856933594) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.6132869720458984) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.528399646282196) { + if (maxDuration_2 <= 0.01901995821390301) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (maxDuration_2 <= 1.9041330814361572) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.781947135925293) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.5280866622924805) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.32349660992622375) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.9139808416366577) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (maxDuration_2 <= 1.8225526809692383) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48887011408805847) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (averageDuration_2 <= -0.5238467454910278) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 1.1538560390472412) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4319878220558167) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04870597831904888) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.40524159371852875) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.23347392678260803) { + if (maxDuration_2 <= 0.16828172653913498) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0709069967269897) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= -0.6811453700065613) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.37002432346344) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397924542427) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2049425840377808) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.178336024284363) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5262112617492676) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.9398770928382874) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.541572332382202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1309216022491455) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (averageDuration_2 <= -0.20028476417064667) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06630406528711319) { + if (maxDuration_2 <= 0.7696770429611206) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.3303449749946594) { + if (averageDuration_2 <= -0.4520481824874878) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.057918906211853) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5003063678741455) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.467879831790924) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3558892011642456) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02710987627506256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 7.006031513214111) { + if (maxDuration_2 <= -0.022688363678753376) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6004821956157684) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.137228362262249) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (maxDuration_2 <= 0.07718826085329056) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0435512401163578) { + if (maxDuration_2 <= 0.0168038927949965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.5833417177200317) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21282974630594254) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30125442147254944) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.2234894186258316) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6182535290718079) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.234639286994934) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9937716126441956) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7819706797599792) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4802909195423126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= 2.1677989959716797) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.093476414680481) { + if (averageDuration_2 <= -0.15875250101089478) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 2.0851775407791138) { + if (maxDuration_2 <= 0.556437075138092) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11400765925645828) { + if (averageDuration_2 <= -0.751485139131546) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1327787134796381) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.26143111288547516) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1711733117699623) { + if (maxDuration_2 <= 0.35787642002105713) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1602819338440895) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.5225780308246613) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7489333748817444) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (averageDuration_2 <= -0.6513746380805969) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7145256400108337) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (maxDuration_2 <= 0.17671563476324081) { + if (averageDuration_2 <= -0.5941755175590515) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5091793835163116) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0107775926589966) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11968792229890823) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.06470723077654839) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6035351753234863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { + if (averageDuration_2 <= -0.6481379568576813) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2756536677479744) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2778780609369278) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11040906235575676) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 0.2224939912557602) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7093262076377869) { + if (averageDuration_2 <= -0.509844034910202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.023589939810335636) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13456559926271439) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= -0.46671725809574127) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.5068370401859283) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.050092317163944244) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (maxDuration_2 <= 0.1294529102742672) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15095919370651245) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6912243962287903) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.43619488179683685) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6963398456573486) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4464073181152344) { + if (averageDuration_2 <= -0.5285005867481232) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8296833634376526) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.677399069070816) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.06424967106431723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= -0.37228943407535553) { + if (maxDuration_2 <= 0.2286256104707718) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8462361097335815) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5836156010627747) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9859866499900818) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.09572261571884155) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4882946312427521) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (maxDuration_2 <= 0.09548944979906082) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1838994361460209) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= -0.548039585351944) { + if (averageDuration_2 <= -0.7452587187290192) { + if (maxDuration_2 <= 0.007058119750581682) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0059900283813477) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9712731540203094) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.5807764828205109) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.048056721687317) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3836115002632141) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.5761618912220001) { + if (maxDuration_2 <= 0.1911594271659851) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0131391882896423) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.18659298866987228) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.5579911172389984) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6055815815925598) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.4701688140630722) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7472152709960938) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9628521203994751) { + if (averageDuration_2 <= -0.5022730529308319) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.32370586693286896) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= -0.7652776539325714) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9538859724998474) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.4351133704185486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 1.8275877237319946) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2397010400891304) { + if (averageDuration_2 <= -0.28144870698451996) { + if (maxDuration_2 <= 0.7009372115135193) { + if (averageDuration_2 <= -0.43845193088054657) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= 3.8542970418930054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0913238525390625) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18284162878990173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17884714156389236) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1800810545682907) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (averageDuration_2 <= -0.3558998256921768) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8892287611961365) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5475223958492279) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0295605659484863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.2984701991081238) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3449589014053345) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.719704806804657) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22398759424686432) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842179775238) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8681597113609314) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.015031187795102596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.070236921310425) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0260080099105835) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.5091347396373749) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.49085164070129395) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9398877024650574) { + if (maxDuration_2 <= 3.6411495208740234) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7452818751335144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7475045919418335) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18802716583013535) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 12.67615270614624) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5397311449050903) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 3.0530433654785156) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8585796356201172) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17847102135419846) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7548507452011108) { + if (maxDuration_2 <= 2.378470778465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.921450436115265) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.10004199296236038) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { + if (maxDuration_2 <= 2.307945489883423) { + if (averageDuration_2 <= -0.3815537840127945) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1408124752342701) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 2.119275212287903) { + if (averageDuration_2 <= -0.42956797778606415) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 4.4696619510650635) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0048209726810455) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48976415395736694) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.56740602850914) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5773622393608093) { + if (maxDuration_2 <= 5.429134130477905) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49154479801654816) { + if (maxDuration_2 <= 0.22083500027656555) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614723324775696) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.778552919626236) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.2055400386452675) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794910855591297) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07156907208263874) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (numDurations_2 <= 3.8542970418930054) { + if (maxDuration_2 <= 0.02867724746465683) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.54273784160614) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4545262455940247) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 4.677119731903076) { + if (averageDuration_2 <= -0.6398843228816986) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3076878786087036) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37819714844226837) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.845037192106247) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24997970461845398) { + if (numDurations_2 <= 3.8542970418930054) { + if (averageDuration_2 <= -0.5004489421844482) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4318339824676514) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.45547595620155334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.3323989361524582) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + if (maxDuration_2 <= 0.2060997560620308) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8611432313919067) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6814408600330353) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4521138668060303) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + if (maxDuration_2 <= 0.38989217579364777) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.41172653436660767) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397924542427) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 4.436450004577637) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3990305662155151) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.361455500125885) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.5302519798278809) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3929396867752075) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7736648917198181) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 2.9522114992141724) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7311728298664093) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5585419535636902) { + if (averageDuration_2 <= 0.1486605927348137) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { + if (averageDuration_2 <= 0.09054486453533173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.118008613586426) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.6331998109817505) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.7575366497039795) { + if (averageDuration_2 <= 1.4525668621063232) { + if (maxDuration_2 <= 1.8205693364143372) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.504787921905518) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.850463032722473) { + if (averageDuration_2 <= 1.3933514952659607) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.2126322984695435) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.6992023289203644) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.4106956720352173) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0437865257263184) { + if (maxDuration_2 <= 0.2709393948316574) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21510637551546097) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.1971208155155182) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.599726915359497) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.375064417719841) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 2.1763941049575806) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.470188617706299) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.883186459541321) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.8774354457855225) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6144105195999146) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976390838623047) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 2.0659995079040527) { + if (averageDuration_2 <= 1.290369689464569) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0709069967269897) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.7397610545158386) { + if (averageDuration_2 <= 0.8549333810806274) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34606271982192993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7403286695480347) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 1.821423590183258) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.404924750328064) { + if (maxDuration_2 <= 0.6772339046001434) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= 2.4786592721939087) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.2537388801574707) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { + if (numDurations_2 <= 0.7239612340927124) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.304485559463501) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.495772123336792) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04143369011580944) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2884135246276855) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.4520399570465088) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3127472847700119) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.60867977142334) { + if (numDurations_2 <= 1.5776892304420471) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.8958566188812256) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.14996526390314102) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.6988641023635864) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.726457417011261) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (numDurations_2 <= -0.12976674735546112) { + if (maxDuration_2 <= 1.5962337255477905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.7316962480545044) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1413493156433105) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.013322114944458) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33028675615787506) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.734416902065277) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6294126510620117) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6758462190628052) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= -0.05943634361028671) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.9026169776916504) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + if (maxDuration_2 <= 0.7086468935012817) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { + if (averageDuration_2 <= 0.29496756196022034) { + if (averageDuration_2 <= 0.16842085123062134) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08231697604060173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3452712893486023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5101791620254517) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5434206128120422) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.459313303232193) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.54273784160614) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { + if (averageDuration_2 <= 0.22652053087949753) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9596757292747498) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6429605782032013) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4608699083328247) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7126609981060028) { + if (maxDuration_2 <= 0.6500527560710907) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.4920990765094757) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.0642496682703495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6805217266082764) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.8774354457855225) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.432702660560608) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3006606101989746) { + if (averageDuration_2 <= 0.10798526182770729) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.984292209148407) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.354845404624939) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26259645819664) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392571926117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.542516827583313) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= 2.51642906665802) { + if (averageDuration_2 <= 0.7064923346042633) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05273069394752383) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.294482946395874) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.5332456827163696) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6031864881515503) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (maxDuration_2 <= 0.7267680764198303) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.8356302082538605) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.6962794363498688) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0358821153640747) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24824069440364838) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6422990262508392) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32935941219329834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.502444714307785) { + if (maxDuration_2 <= 0.8869432508945465) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.5068024098873138) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8702456951141357) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.013878376223146915) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1976703181862831) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + if (averageDuration_2 <= 0.04693296737968922) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04728369414806366) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 2.4848499298095703) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { + if (maxDuration_2 <= 0.6186196208000183) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.260116338729858) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0110052227973938) { + if (averageDuration_2 <= 0.4915490001440048) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24874429404735565) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2788926362991333) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.8173737525939941) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + if (numDurations_2 <= -1.837222695350647) { + if (maxDuration_2 <= 0.28434236347675323) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.442385733127594) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.930047035217285) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.631614089012146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.6582285463809967) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.273658275604248) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2071656584739685) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.469818353652954) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.531028747558594) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5517327040433884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8020380735397339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.637903451919556) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.486834526062012) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.522068202495575) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { + if (averageDuration_2 <= 1.1721805334091187) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.830192446708679) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { + if (cpuCoreIdleTimesPercentage_5_2 <= -5.132140636444092) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1497039794921875) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.055688202381134) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.554762065410614) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.4071969985961914) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.11133947968482971) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.1149210929870605) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.800664186477661) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6528968811035156) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.7993290424346924) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.2214198112487793) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165159225464) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 0.3964579850435257) { + if (averageDuration_2 <= -0.08234961330890656) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0978952050209045) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8546172976493835) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.390951991081238) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.08504298329353333) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8798046708106995) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.6698808670043945) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.454002380371094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -3.1456851959228516) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 0.385555163025856) { + if (averageDuration_2 <= 0.20968328416347504) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.2824081927537918) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18522001057863235) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.4125157594680786) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.35368120670318604) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.09199321269989) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4598904252052307) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.024251937866211) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19566070288419724) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.30949611961841583) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.136139154434204) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.16410893201828) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.005236268043518) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.7187942266464233) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.460745394229889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616687893867493) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.319916009902954) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.048766613006592) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1213459968566895) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.5058279037475586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.994012176990509) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (averageDuration_2 <= 0.5401733815670013) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.182707667350769) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611977934837341) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461599349975586) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.330597400665283) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0260956287384033) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377739667892456) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025969982147217) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4375660419464111) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { + if (maxDuration_2 <= 0.28874412178993225) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.345078229904175) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8317449688911438) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1009268760681152) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.6988641023635864) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.2400052547454834) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7180163860321045) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.34257173538208) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.240623712539673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.211121559143066) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.207621097564697) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025969982147217) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= -0.02070558536797762) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.8774354457855225) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9925618767738342) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.170281648635864) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.60867977142334) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.7453612089157104) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2293047308921814) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2559274435043335) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.7730573415756226) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1326106786727905) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.647126168012619) { + if (maxDuration_2 <= 0.8377886414527893) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3478758335113525) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.38911469280719757) { + if (maxDuration_2 <= 0.8200269639492035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 2.1897956132888794) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { + if (averageDuration_2 <= 2.0180875062942505) { + if (numMissedDeadlines_2 <= 4.563007950782776) { + if (averageDuration_2 <= -0.04849856346845627) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.288592517375946) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.8727827072143555) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 2.1797780990600586) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (averageDuration_2 <= 0.08269862830638885) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numMissedDeadlines_2 <= 4.563007950782776) { + if (maxDuration_2 <= 0.8466176688671112) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.718425154685974) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.2029491662979126) { + if (maxDuration_2 <= 0.7737343907356262) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8489216864109039) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8015914261341095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3338761925697327) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6955958604812622) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9345415830612183) { + if (maxDuration_2 <= 0.7773562371730804) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9898547530174255) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.442385733127594) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.4682307243347168) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (averageDuration_2 <= 1.189909279346466) { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.6782695353031158) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8109508752822876) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.304485559463501) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9236379861831665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 1.7793945670127869) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.808453768491745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8431202173233032) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { + if (maxDuration_2 <= 1.098124086856842) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.851856768131256) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0922346115112305) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8827711343765259) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4990555047988892) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9364900290966034) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.2291572466492653) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.951200842857361) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 1.543505609035492) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.582572817802429) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616853594779968) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 2.2258235216140747) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0461134016513824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.331530213356018) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0809954404830933) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.075546741485596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3106040358543396) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815161705017) { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.218616247177124) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.604988932609558) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 1.8012365698814392) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.8564924001693726) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.06201171875) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.531028747558594) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 1.5776891708374023) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.5477566719055176) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.396687924861908) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4991838932037354) { + if (maxDuration_2 <= 1.411458671092987) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1459314823150635) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { + if (averageDuration_2 <= 1.667149305343628) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6797280311584473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.851856768131256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.679324150085449) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.857966423034668) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -5.289881944656372) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { + if (maxDuration_2 <= 1.8076249361038208) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4803755283355713) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8675131797790527) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9170226454734802) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.370543122291565) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.4852719902992249) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.905318558216095) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.83640456199646) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7590811252593994) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.366545557975769) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -6.090893983840942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (maxDuration_2 <= 1.6119794845581055) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.350725889205933) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.068911075592041) { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.084824323654175) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1884634494781494) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.292544722557068) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.319916009902954) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3047654926776886) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3218483328819275) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.702006757259369) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.5376117378473282) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4133901596069336) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6102865934371948) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3418726325035095) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.0849900245666504) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 1.6949339509010315) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.176781415939331) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.446711778640747) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.641247868537903) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3935690522193909) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { + if (averageDuration_2 <= 2.041002631187439) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.1149210929870605) { + if (averageDuration_2 <= 1.633895456790924) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.3491384983062744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9994883835315704) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.9023451507091522) { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.013322114944458) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.188086748123169) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -5.224905490875244) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.498723864555359) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.751004695892334) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9736347496509552) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.655320167541504) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.471769332885742) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2294156551361084) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.6698808670043945) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6146548986434937) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2547974586486816) { + if (numMissedDeadlines_2 <= 4.563007950782776) { + if (cpuCoreIdleTimesPercentage_7_2 <= -5.141047954559326) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4283981323242188) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.631614089012146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4851100444793701) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.781385064125061) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.52111154794693) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 1.77457195520401) { + if (maxDuration_2 <= 1.265385627746582) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6666991114616394) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 1.4920134544372559) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.488429546356201) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1459453105926514) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 2.2893961668014526) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.221854530274868) { + if (cpuCoreIdleTimesPercentage_7_2 <= -4.470188617706299) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.45564341545105) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3666815757751465) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -4.531028747558594) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.091283082962036) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.345078229904175) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (maxDuration_2 <= 1.9867419600486755) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.597325921058655) { + if (averageDuration_2 <= 2.0434041023254395) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.9670439958572388) { + if (averageDuration_2 <= 1.0895439982414246) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 5.202355623245239) { + if (maxDuration_2 <= 0.8233751654624939) { + if (averageDuration_2 <= 1.2072237133979797) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9852243959903717) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.655748724937439) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5052746534347534) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.46462877094745636) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.428841769695282) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + if (numDurations_2 <= -0.4143427312374115) { + if (maxDuration_2 <= 0.24061018973588943) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.1447945162653923) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.399016797542572) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9464494585990906) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1127390265464783) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + if (maxDuration_2 <= 2.834039092063904) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613980650901794) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4009926319122314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4252933859825134) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4600907564163208) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.7907878756523132) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.0572614073753357) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9362237751483917) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8813528418540955) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -5.289881944656372) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.835106372833252) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.803012490272522) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.151027202606201) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.149576187133789) { + if (numMissedDeadlines_2 <= 4.563007950782776) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { + if (averageDuration_2 <= 2.5127698183059692) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { + if (averageDuration_2 <= 2.7541388273239136) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 3.13879930973053) { + if (cpuCoreIdleTimesPercentage_4_2 <= -4.027185082435608) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1600269079208374) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 1.7837414741516113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 2.542690634727478) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6604793667793274) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.014568865299225) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0507539510726929) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6338953971862793) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.801955223083496) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0869851112365723) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.5236746072769165) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -1.837222695350647) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0119067430496216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.961464166641235) { + if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { + if (averageDuration_2 <= 2.5150275230407715) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.8748806715011597) { + if (maxDuration_2 <= 1.7359243035316467) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3055525422096252) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (averageDuration_2 <= 0.5719016194343567) { + if (numDurations_2 <= -0.6989187151193619) { + if (averageDuration_2 <= 0.07649639993906021) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + if (maxDuration_2 <= 0.2240009680390358) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.26107440888881683) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3378981351852417) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6615205407142639) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.06037459522485733) { + if (averageDuration_2 <= 0.02208957076072693) { + if (maxDuration_2 <= 0.30896005034446716) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { + if (averageDuration_2 <= 0.24445046484470367) { + if (maxDuration_2 <= 0.32748159766197205) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29349569976329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821968436241) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28652288764715195) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.5293399691581726) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (maxDuration_2 <= 0.38118231296539307) { + if (averageDuration_2 <= 0.4230045974254608) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4184390902519226) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5553891062736511) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8387055993080139) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.3291455805301666) { + if (averageDuration_2 <= 0.2996497303247452) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.3572763353586197) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.062345417216420174) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4740549325942993) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3713284134864807) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.41237059235572815) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 0.5424788296222687) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.7656015157699585) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { + if (maxDuration_2 <= 1.1129506826400757) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4067111909389496) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7311698794364929) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.351149246096611) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + if (averageDuration_2 <= 0.12465944513678551) { + if (maxDuration_2 <= 0.7832927405834198) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6686082780361176) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7511109113693237) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.01048527006059885) { + if (maxDuration_2 <= 0.2389868199825287) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7504059076309204) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7483816742897034) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913831710815) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.134857416152954) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.43490731716156) { + if (maxDuration_2 <= 0.1703026443719864) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.203004002571106) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 0.18470660597085953) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.950354814529419) { + if (averageDuration_2 <= 0.7556245028972626) { + if (maxDuration_2 <= 0.42229805886745453) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48527152836322784) { + if (averageDuration_2 <= 0.5910443365573883) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.04611337184906) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12226511165499687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07891198061406612) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9396538734436035) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + if (maxDuration_2 <= 1.2051023840904236) { + if (maxDuration_2 <= 0.44002945721149445) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.091744314879179) { + if (averageDuration_2 <= 0.8598925769329071) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.349451407790184) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.43471239507198334) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.724583625793457) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7416684925556183) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6342105865478516) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 1.3143450617790222) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49390411376953125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8384836912155151) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.0145689249038696) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9062472879886627) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.9390407502651215) { + if (maxDuration_2 <= 0.4803650379180908) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (averageDuration_2 <= -0.07482349872589111) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5795984268188477) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3655945956707001) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.9084832668304443) { + if (averageDuration_2 <= 0.0012164053623564541) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09357177093625069) { + if (maxDuration_2 <= 1.3117946982383728) { + if (maxDuration_2 <= 0.1487571969628334) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.905464768409729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29803667962551117) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8714234828948975) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.777886837720871) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5322262048721313) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5424161851406097) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { + if (averageDuration_2 <= 0.6368220150470734) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.32581014931201935) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6577824354171753) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 1.008537232875824) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9306732416152954) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27020205557346344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921536922454834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.49233707785606384) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4125160872936249) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { + if (maxDuration_2 <= 1.0592498183250427) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14956074953079224) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3192725330591202) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1329648569226265) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41851629316806793) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41889698803424835) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991199404001) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053233623505) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5344177782535553) { + if (averageDuration_2 <= 2.523739218711853) { + if (averageDuration_2 <= 1.5712027549743652) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8996076881885529) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { + if (averageDuration_2 <= 2.4023046493530273) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7965860366821289) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= -0.017729665152728558) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (numDurations_2 <= 3.2851450443267822) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.2370796948671341) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.91253662109375) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4284600615501404) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7041893005371094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4519153833389282) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.115258574485779) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.533225178718567) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { + if (averageDuration_2 <= -0.05249614082276821) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { + if (maxDuration_2 <= 0.028340275399386883) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.051359884440898895) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1289394274353981) { + if (maxDuration_2 <= 0.8915399610996246) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37297840416431427) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.995977759361267) { + if (maxDuration_2 <= 0.21579502522945404) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.45206883549690247) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22742345184087753) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3584911823272705) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33819037675857544) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.11382882669568062) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.040633410215378) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9848006963729858) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8380184173583984) { + if (maxDuration_2 <= 0.004692597081884742) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4484702348709106) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (averageDuration_2 <= -0.07942678034305573) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.42254483699798584) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6226781606674194) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.271142840385437) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { + if (averageDuration_2 <= -0.01869127992540598) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.35231979191303253) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4931092709302902) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (maxDuration_2 <= 0.34423041343688965) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0108182430267334) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3071543276309967) { + if (maxDuration_2 <= 1.0780044794082642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.970194160938263) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397924542427) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26054825633764267) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.2469632625579834) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (maxDuration_2 <= 1.5519875884056091) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.5477566719055176) { + if (averageDuration_2 <= 0.2389715388417244) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.116235136985779) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3895057439804077) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.677799701690674) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41473303735256195) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5900271534919739) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10434138402342796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7321376204490662) { + if (averageDuration_2 <= 0.6705574095249176) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.568812906742096) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.57365220785141) { + if (numDurations_2 <= 3.2851450443267822) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4451440572738647) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.744037687778473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.38823847472667694) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.6051508486270905) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333690106868744) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (maxDuration_2 <= 0.11691359803080559) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.616599202156067) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9804890751838684) { + if (maxDuration_2 <= 0.20280230790376663) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.465425193309784) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.19301842898130417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0432409048080444) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { + if (maxDuration_2 <= 0.7784756720066071) { + if (averageDuration_2 <= 0.00045019247045274824) { + if (numDurations_2 <= 2.1468411684036255) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.868710458278656) { + if (maxDuration_2 <= 0.5014396905899048) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5386690497398376) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.014568865299225) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5480102896690369) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.5803462862968445) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862634658813) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5405186712741852) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5388980507850647) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335530638694763) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9553164541721344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9171308279037476) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.1604827642440796) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8406128585338593) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4208534359931946) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.43234983086586) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.11082524061203) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.140161156654358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8299274742603302) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.403375267982483) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7640702724456787) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (maxDuration_2 <= 0.7639706134796143) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.4470726549625397) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.6281538009643555) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3796340823173523) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6138985455036163) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7035243213176727) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5435339510440826) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2256015539169312) { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575631141663) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + if (numDurations_2 <= 2.1468411684036255) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.563613772392273) { + if (averageDuration_2 <= 0.19177384674549103) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6711389422416687) { + if (averageDuration_2 <= 0.7540326118469238) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6180667579174042) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.7909364998340607) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { + if (averageDuration_2 <= 0.2766471654176712) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4291403889656067) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0604326725006104) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18441375344991684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6570369601249695) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.076667070388794) { + if (averageDuration_2 <= 0.5933231711387634) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5548446774482727) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.3226674795150757) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.034745775163173676) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= -0.013819535728543997) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 1.469601571559906) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6936079263687134) { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36150892078876495) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { + if (averageDuration_2 <= 0.11544063314795494) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0121926069259644) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0727112777531147) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8087291717529297) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 0.15957676619291306) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0551278591156006) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 0.09759169071912766) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15939360857009888) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2373237609863281) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4877425730228424) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (averageDuration_2 <= 0.05946826748549938) { + if (maxDuration_2 <= 0.5331488847732544) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.01603667251765728) { + if (averageDuration_2 <= 0.013127036858350039) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7630694508552551) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.036575973033905) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0765175819396973) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7394643425941467) { + if (maxDuration_2 <= 0.7627500891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.466018319129944) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.027762568555772305) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777280002832) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 1.4731804728507996) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.6281538009643555) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8408084511756897) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 1.8594541549682617) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { + if (numDurations_2 <= -1.2680706679821014) { + if (averageDuration_2 <= 0.2305276244878769) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (maxDuration_2 <= 0.49224594235420227) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.432234525680542) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (averageDuration_2 <= 0.5220351219177246) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { + if (averageDuration_2 <= 0.3472038060426712) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8395796120166779) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32139360904693604) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (averageDuration_2 <= 0.675759881734848) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0971235036849976) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (maxDuration_2 <= 0.9694303870201111) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2693729996681213) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0708580613136292) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8715697526931763) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { + if (maxDuration_2 <= 0.27050620317459106) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.5094808042049408) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9819397926330566) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.7751853168010712) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9384127259254456) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15529866516590118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4067864269018173) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.2571268379688263) { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4049559831619263) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0730167627334595) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + if (averageDuration_2 <= 0.1526781991124153) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.309035986661911) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608147740364075) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.15745744854211807) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 0.4246281683444977) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.00414776802063) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + if (averageDuration_2 <= 0.17485319823026657) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9452307224273682) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5874207615852356) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.706470251083374) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.65778249502182) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8826395273208618) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.312984347343445) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= 2.7159931659698486) { + if (maxDuration_2 <= 0.8714329898357391) { + if (averageDuration_2 <= 0.058840448036789894) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2660975456237793) { + if (numDurations_2 <= -0.12976674735546112) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.3211751878261566) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4400136470794678) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7145272493362427) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.175323273986578) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { + if (maxDuration_2 <= 0.3895578533411026) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7562755346298218) { + if (averageDuration_2 <= 0.050177525728940964) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5181328058242798) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.1941758468747139) { + if (maxDuration_2 <= 0.026648390339687467) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1611754074692726) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.7670581638813019) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0340837240219116) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.20685764402151108) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8970982432365417) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.13847704604268074) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 0.29203398525714874) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5556002855300903) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4452753067016602) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4602272510528564) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.16949505358934402) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3361035585403442) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1694764569401741) { + if (averageDuration_2 <= 0.06819140911102295) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.6698195934295654) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612407684326172) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 1.3514944911003113) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9102553725242615) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6891494989395142) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numDurations_2 <= 3.8542970418930054) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.017462730407715) { + if (averageDuration_2 <= 0.1209564283490181) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { + if (maxDuration_2 <= 0.5668059587478638) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.695732593536377) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.14209871739149094) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8102989792823792) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.440079003572464) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 0.0622138287872076) { + if (maxDuration_2 <= 0.22833936661481857) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619540572166443) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.1465429225936532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (averageDuration_2 <= 0.0418302696198225) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7781811356544495) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0053760707378387) { + if (maxDuration_2 <= 0.5117779970169067) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1103258728981018) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= -0.01706415507942438) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.062225885689258575) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 0.629857212305069) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6986220180988312) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { + if (maxDuration_2 <= 0.05979891121387482) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17394530028104782) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (numMissedDeadlines_2 <= 0.4979674816131592) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { + if (averageDuration_2 <= 0.12261155247688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 0.08254513517022133) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615398049354553) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206787645817) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46171373128891) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617088437080383) { + if (maxDuration_2 <= 0.5861581861972809) { + if (cpuCoreIdleTimesPercentage_2_2 <= -3.035153388977051) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 0.9801110327243805) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40770813822746277) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { + if (numDurations_2 <= -1.837222695350647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609662294387817) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.66507887840271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.182704448699951) { + if (maxDuration_2 <= 0.7383172512054443) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.5657902359962463) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4553073644638062) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615808129310608) { + if (maxDuration_2 <= 0.26559029519557953) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.33529411256313324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.5403713285923004) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7927008867263794) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607444405555725) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (numDurations_2 <= -0.12976674735546112) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.698617547750473) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13934404402971268) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7571576237678528) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 0.5010522305965424) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4206048846244812) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15307319909334183) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4604942798614502) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4604288339614868) { + if (averageDuration_2 <= 0.8754375278949738) { + if (averageDuration_2 <= 0.8354138433933258) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.411447286605835) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.831105351448059) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9362237751483917) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.9516109228134155) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.161177158355713) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8453426361083984) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.895442843437195) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1838470920920372) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386044681072235) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9760718941688538) { + if (maxDuration_2 <= 0.0609410535544157) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.155582070350647) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.162376046180725) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.981515049934387) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { + if (maxDuration_2 <= 1.1187833547592163) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.625548005104065) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7541018724441528) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 2.0860217809677124) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.627090334892273) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36042580008506775) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.47598397731781) { + if (maxDuration_2 <= 1.5648765563964844) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3530983328819275) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21876464039087296) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0160834789276123) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291220307350159) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4594137072563171) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 2.5274583101272583) { + if (maxDuration_2 <= 0.6473707854747772) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.0760540664196014) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.3350065350532532) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.4484865665435791) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 1.2962273359298706) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48443716764450073) { + if (averageDuration_2 <= 1.9543921947479248) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.473419725894928) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 2.684321403503418) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023990750313) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5266796350479126) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5847970843315125) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.50289386510849) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.47843292355537415) { + if (numDurations_2 <= -0.6989187151193619) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.756723016500473) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.2287803292274475) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5188332498073578) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9485477805137634) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07451411336660385) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 2.045895576477051) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 1.1645368933677673) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1055437326431274) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.013568496098741889) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.2544687390327454) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (averageDuration_2 <= 1.4578538537025452) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.053328411653637886) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15973930805921555) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3782844841480255) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.03074631281197071) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { + if (averageDuration_2 <= 2.1465831995010376) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8287606239318848) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4503361582756042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5649480819702148) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30781756341457367) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9758623242378235) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08503397554159164) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660716414452) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8293795585632324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.8734205961227417) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45773518085479736) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.046487331390381) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26091842353343964) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2057830095291138) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { + if (averageDuration_2 <= 1.144224464893341) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.14249117905274034) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.875568300485611) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 2.9560892581939697) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 3.7313427925109863) { + if (averageDuration_2 <= 3.054486393928528) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473682403564) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01704739686101675) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.162677824497223) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512360334396) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9170674681663513) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8754225969314575) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354000866413) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1387597918510437) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.091252326965332) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746338248253) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06420721299946308) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 0.022722860798239708) { + if (numDurations_2 <= 1.8622652292251587) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 2.264540195465088) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22673305124044418) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0318717658519745) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8314541578292847) { + if (averageDuration_2 <= 0.040018025785684586) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8115573525428772) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.023876428604125977) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 3.012301206588745) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.08482426404953) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9206715822219849) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744978427887) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (maxDuration_2 <= 1.8306444883346558) { + if (maxDuration_2 <= 1.822722315788269) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (averageDuration_2 <= 2.158921957015991) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.211506485939026) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { + if (averageDuration_2 <= -0.05623660609126091) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.6698195934295654) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 2.8249666690826416) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616902470588684) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.6202406883239746) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6818858683109283) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4757949411869049) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3632214069366455) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197647094727) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } else { + if (maxDuration_2 <= 1.254760980606079) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7751321494579315) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.8851237297058105) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { + if (averageDuration_2 <= -0.090853750705719) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24314958602190018) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7065825760364532) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.3004387617111206) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613844156265259) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45699334144592285) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 0.23482564836740494) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47463831305503845) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617801308631897) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.397545099258423) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3710131645202637) { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5811467468738556) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.6187161207199097) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774529695510864) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.783410906791687) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461028814315796) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.074470639228821) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7703684866428375) { + if (averageDuration_2 <= 1.3027046918869019) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3587234020233154) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.027474880218506) { + if (averageDuration_2 <= 0.35692231357097626) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.01198148727417) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5260390341281891) { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.0048857927322388) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6991206109523773) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { + if (maxDuration_2 <= 1.4744365811347961) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (averageDuration_2 <= 0.5500186085700989) { + if (averageDuration_2 <= 0.5365014970302582) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 3.4690970182418823) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 1.4101492166519165) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.009798526763916) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 3.086870312690735) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7250277698040009) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (numDurations_2 <= -1.2680706679821014) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2858968377113342) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (averageDuration_2 <= 0.9354912638664246) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6008046567440033) { + if (maxDuration_2 <= 2.130601406097412) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.8508365154266357) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.399388611316681) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.2662731409072876) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.409091591835022) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6417961716651917) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2913947105407715) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.729442596435547) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533344954252243) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 0.9473049342632294) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (averageDuration_2 <= 0.3951658606529236) { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + if (maxDuration_2 <= 1.4830199480056763) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.36880886554718) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1965911984443665) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9236922264099121) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 0.6821088790893555) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7636559307575226) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6810545921325684) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 0.9183510541915894) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.738096833229065) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3962726593017578) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2829664945602417) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9899911880493164) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 0.7443805634975433) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { + if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { + if (maxDuration_2 <= 1.0872865915298462) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4375524520874023) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5093331634998322) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 2.34213924407959) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.662302851676941) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.9165481925010681) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + if (numDurations_2 <= -1.2680706679821014) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { + if (maxDuration_2 <= 0.38587021827697754) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { + if (averageDuration_2 <= 3.0811301469802856) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (maxDuration_2 <= 2.7767266035079956) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 1.0188051462173462) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { + if (averageDuration_2 <= 0.45915351808071136) { + if (numDurations_2 <= 0.43938523530960083) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619266986846924) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4526512622833252) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.140251100063324) { + if (numDurations_2 <= -0.6989187151193619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4599754214286804) { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6862609386444092) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -3.0757460594177246) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.802748203277588) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (numDurations_2 <= 3.2851450443267822) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3052783012390137) { + if (numDurations_2 <= 4.4234490394592285) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (maxDuration_2 <= 0.38272470235824585) { + if (maxDuration_2 <= 0.38140779733657837) { + if (averageDuration_2 <= 0.5128093361854553) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6829959154129028) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 4.255645513534546) { + if (maxDuration_2 <= 4.313700914382935) { + if (numMissedDeadlines_2 <= 2.5304877758026123) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.021501914598047733) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7889090925455093) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 0.221229687333107) { + if (cpuCoreIdleTimesPercentage_6_2 <= 1.1603711545467377) { + if (maxDuration_2 <= 3.1527856588363647) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.49811258912086487) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5125864148139954) { + if (averageDuration_2 <= 1.1393049955368042) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.43777458369731903) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (maxDuration_2 <= 3.1482774019241333) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1735256388783455) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { + if (maxDuration_2 <= 3.0874221324920654) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6590568423271179) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18648068606853485) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { + if (averageDuration_2 <= 2.2011454105377197) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8165844082832336) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { + if (cpuCoreIdleTimesPercentage_5_2 <= 1.1083666682243347) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.05064010247588158) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8294543623924255) { + if (cpuCoreIdleTimesPercentage_5_2 <= -3.6463054418563843) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.348728060722351) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6814691126346588) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16553408652544022) { + if (averageDuration_2 <= 2.5150288343429565) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4092864990234375) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { + return ThrottleDecision::THROTTLE_70; + } else { + if (averageDuration_2 <= 1.3242594003677368) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (averageDuration_2 <= 0.7459826171398163) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591690063477) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8989859223365784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 3.342008113861084) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 1.8046969771385193) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3908380270004272) { + if (maxDuration_2 <= 3.75872004032135) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.795726180076599) { + if (averageDuration_2 <= 0.13456124067306519) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0572760105133057) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1929267793893814) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 4.021517872810364) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 3.290730357170105) { + if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1804072856903076) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (averageDuration_2 <= 2.957960844039917) { + if (cpuCoreIdleTimesPercentage_2_2 <= -2.6495232582092285) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (maxDuration_2 <= 3.4700006246566772) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.969179093837738) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 3.34129798412323) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (numMissedDeadlines_2 <= 4.563007950782776) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } else { + if (numMissedDeadlines_2 <= 4.563007950782776) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3935797810554504) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03771708160638809) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905557394028) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { + if (averageDuration_2 <= 0.8101759552955627) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + if (averageDuration_2 <= 1.3211275935173035) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 5.565899610519409) { + if (averageDuration_2 <= 0.303888663649559) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3421768546104431) { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.543883740901947) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.2883365154266357) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 4.846290826797485) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.839552640914917) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3907485604286194) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.9961256682872772) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.56477789580822) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (maxDuration_2 <= 4.965301990509033) { + if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7128522992134094) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8075558245182037) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5088971257209778) { + if (averageDuration_2 <= 1.1261682510375977) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199840635061264) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 4.810176849365234) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.781621515750885) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.567220538854599) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { + if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40300142765045166) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 3.712875247001648) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06337766721844673) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= -0.163956917822361) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (maxDuration_2 <= 3.206650972366333) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05081144720315933) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.057646654546260834) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } else { + if (averageDuration_2 <= 6.196000814437866) { + if (cpuCoreIdleTimesPercentage_2_2 <= -1.4520399570465088) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.012336883693933487) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3307592868804932) { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6843329668045044) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 5.6075217723846436) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6345682740211487) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.4803755283355713) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4960800111293793) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.553554117679596) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2230907753109932) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3361176252365112) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 4.569088697433472) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5646337866783142) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.5634623765945435) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2467628717422485) { + if (cpuCoreIdleTimesPercentage_1_2 <= -1.9045336842536926) { + if (cpuCoreIdleTimesPercentage_0_2 <= -2.4556432962417603) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.454709768295288) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5829074382781982) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (maxDuration_2 <= 4.546690940856934) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4269262552261353) { + if (averageDuration_2 <= 6.02677845954895) { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { + if (averageDuration_2 <= 4.786563158035278) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9241895377635956) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (averageDuration_2 <= 5.745266437530518) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 5.0169923305511475) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.990395188331604) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149398297071457) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162634164094925) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } else { + if (averageDuration_2 <= 7.0189292430877686) { + if (maxDuration_2 <= 6.2119410037994385) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5090467035770416) { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3819066286087036) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 6.9840497970581055) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07530201226472855) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (averageDuration_2 <= 8.04335618019104) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (maxDuration_2 <= 5.035607099533081) { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4360809326171875) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.916453778743744) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.158440463244915) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9223034381866455) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (maxDuration_2 <= 5.225733757019043) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { + if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { + if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { + if (maxDuration_2 <= 6.364424705505371) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2087278366088867) { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9995294213294983) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9250659346580505) { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { + if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396028995514) { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.4106956720352173) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.914979875087738) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (averageDuration_2 <= 8.337781429290771) { + if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960221290588) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7750936150550842) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= -2.762808322906494) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } + } + } + } else { + if (averageDuration_2 <= 9.630945205688477) { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7669174075126648) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6364741921424866) { + if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6809051632881165) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940382003784) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2523229196667671) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 2.811887502670288) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 2.146018385887146) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { + if (averageDuration_2 <= 9.192076683044434) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6117304563522339) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } else { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6280301809310913) { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { + if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { + if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } else { + if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6918853223323822) { + if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6562197804450989) { + if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40245582163333893) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { + if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuPolicyAverageFrequencyHz_1_2 <= 1.314504325389862) { + return ThrottleDecision::NO_THROTTLE; + } else { + return ThrottleDecision::THROTTLE_70; + } + } + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { + if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { + return ThrottleDecision::NO_THROTTLE; + } else { + if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { + return ThrottleDecision::THROTTLE_70; + } else { + if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { + return ThrottleDecision::THROTTLE_70; + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } else { + return ThrottleDecision::NO_THROTTLE; + } + } + } + } + } + } + } + } + } + } + } + } diff --git a/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuConfigTest.cpp b/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuConfigTest.cpp new file mode 100644 index 00000000..e16515be --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuConfigTest.cpp @@ -0,0 +1,131 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "adaptivecpu/AdaptiveCpuConfig.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using std::chrono_literals::operator""ms; +using std::chrono_literals::operator""min; + +class AdaptiveCpuConfigTest : public ::testing::Test { + protected: + void SetUp() override { + android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", ""); + android::base::SetProperty("debug.adaptivecpu.hint_timeout_ms", ""); + android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", ""); + android::base::SetProperty("debug.adaptivecpu.random_throttle_options", ""); + android::base::SetProperty("debug.adaptivecpu.enabled_hint_timeout_ms", ""); + } +}; + +TEST(AdaptiveCpuConfigTest, valid) { + android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", "25"); + android::base::SetProperty("debug.adaptivecpu.hint_timeout_ms", "500"); + android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", "25"); + android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,3,4"); + android::base::SetProperty("debug.adaptivecpu.enabled_hint_timeout_ms", "1000"); + const AdaptiveCpuConfig expectedConfig{ + .iterationSleepDuration = 25ms, + .hintTimeout = 500ms, + .randomThrottleDecisionProbability = 0.25, + .enabledHintTimeout = 1000ms, + .randomThrottleOptions = {ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_70, + ThrottleDecision::THROTTLE_80}, + }; + AdaptiveCpuConfig actualConfig; + ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); + ASSERT_EQ(actualConfig, expectedConfig); +} + +TEST(AdaptiveCpuConfigTest, defaultConfig) { + android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", ""); + android::base::SetProperty("debug.adaptivecpu.hint_timeout_ms", ""); + android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", ""); + android::base::SetProperty("debug.adaptivecpu.random_throttle_options", ""); + android::base::SetProperty("debug.adaptivecpu.enabled_hint_timeout_ms", ""); + AdaptiveCpuConfig actualConfig; + ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); + ASSERT_EQ(actualConfig, AdaptiveCpuConfig::DEFAULT); +} + +TEST(AdaptiveCpuConfigTest, iterationSleepDuration_belowMin) { + android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", "2"); + AdaptiveCpuConfig actualConfig; + ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); + ASSERT_EQ(actualConfig.iterationSleepDuration, 20ms); +} + +TEST(AdaptiveCpuConfigTest, iterationSleepDuration_negative) { + android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", "-100"); + AdaptiveCpuConfig actualConfig; + ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); + ASSERT_EQ(actualConfig.iterationSleepDuration, 1000ms); +} + +TEST(AdaptiveCpuConfigTest, randomThrottleDecisionProbability_float) { + android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", "0.5"); + AdaptiveCpuConfig actualConfig; + ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); + ASSERT_EQ(actualConfig.randomThrottleDecisionProbability, 0); +} + +TEST(AdaptiveCpuConfigTest, randomThrottleDecisionProbability_tooBig) { + android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", "101"); + AdaptiveCpuConfig actualConfig; + ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); +} + +TEST(AdaptiveCpuConfigTest, randomThrottleOptions_invalidThrottle) { + android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1,2,9"); + AdaptiveCpuConfig actualConfig; + ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); +} + +TEST(AdaptiveCpuConfigTest, randomThrottleOptions_wrongDelim) { + android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1.2,3"); + AdaptiveCpuConfig actualConfig; + ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); +} + +TEST(AdaptiveCpuConfigTest, randomThrottleOptions_wrongNumber) { + android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1,2a,3"); + AdaptiveCpuConfig actualConfig; + ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); +} + +TEST(AdaptiveCpuConfigTest, randomThrottleOptions_straySpace) { + android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1 ,2,3"); + AdaptiveCpuConfig actualConfig; + ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); + android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1,2,3 "); + ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuStatsTest.cpp b/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuStatsTest.cpp new file mode 100644 index 00000000..09797295 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuStatsTest.cpp @@ -0,0 +1,129 @@ + +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "adaptivecpu/AdaptiveCpuStats.h" +#include "mocks.h" + +using testing::HasSubstr; +using testing::Return; +using std::chrono_literals::operator""ns; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +TEST(AdaptiveCpuStatsTest, singleRun) { + std::unique_ptr timeSource = std::make_unique(); + + EXPECT_CALL(*timeSource, GetTime()) + .Times(3) + .WillOnce(Return(1000ns)) + .WillOnce(Return(1100ns)) + .WillOnce(Return(1200ns)); + + AdaptiveCpuStats stats(std::move(timeSource)); + stats.RegisterStartRun(); + stats.RegisterSuccessfulRun(ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_60, {}, + AdaptiveCpuConfig::DEFAULT); + + std::stringstream stream; + stats.DumpToStream(stream); + EXPECT_THAT(stream.str(), HasSubstr("- Successful runs / total runs: 1 / 1\n")); + EXPECT_THAT(stream.str(), HasSubstr("- Total run duration: 100.000000ns\n")); + EXPECT_THAT(stream.str(), HasSubstr("- Average run duration: 100.000000ns\n")); + EXPECT_THAT(stream.str(), HasSubstr("- Running time fraction: 0.5\n")); + EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_60: 1\n")); +} + +TEST(AdaptiveCpuStatsTest, multipleRuns) { + std::unique_ptr timeSource = std::make_unique(); + + EXPECT_CALL(*timeSource, GetTime()) + .Times(9) + .WillOnce(Return(1000ns)) // start #1 + .WillOnce(Return(1100ns)) // success #1 + .WillOnce(Return(2000ns)) // start #2 + .WillOnce(Return(2200ns)) // success #2 + .WillOnce(Return(3000ns)) // start #3 + .WillOnce(Return(3100ns)) // success #3 + .WillOnce(Return(4000ns)) // start #4 + .WillOnce(Return(4800ns)) // success #4 + .WillOnce(Return(5000ns)); // dump + + AdaptiveCpuStats stats(std::move(timeSource)); + stats.RegisterStartRun(); + stats.RegisterSuccessfulRun(ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_60, + // Ignored, as this is the first call. + {.numDurations = 100000, .numMissedDeadlines = 123}, + AdaptiveCpuConfig::DEFAULT); + stats.RegisterStartRun(); + stats.RegisterSuccessfulRun(ThrottleDecision::THROTTLE_60, ThrottleDecision::THROTTLE_70, + {.numDurations = 100, .numMissedDeadlines = 10}, + AdaptiveCpuConfig::DEFAULT); + stats.RegisterStartRun(); + stats.RegisterSuccessfulRun(ThrottleDecision::THROTTLE_70, ThrottleDecision::THROTTLE_60, + {.numDurations = 50, .numMissedDeadlines = 1}, + AdaptiveCpuConfig::DEFAULT); + stats.RegisterStartRun(); + stats.RegisterSuccessfulRun(ThrottleDecision::THROTTLE_60, ThrottleDecision::THROTTLE_80, + {.numDurations = 200, .numMissedDeadlines = 20}, + AdaptiveCpuConfig::DEFAULT); + + std::stringstream stream; + stats.DumpToStream(stream); + EXPECT_THAT(stream.str(), HasSubstr("- Successful runs / total runs: 4 / 4\n")); + EXPECT_THAT(stream.str(), HasSubstr("- Total run duration: 1.200000us\n")); + EXPECT_THAT(stream.str(), HasSubstr("- Average run duration: 300.000000ns\n")); + EXPECT_THAT(stream.str(), HasSubstr("- Running time fraction: 0.3\n")); + EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_60: 2\n")); + EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_70: 1\n")); + EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_60: 30 / 300 (0.1)\n")); + EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_70: 1 / 50 (0.02)\n")); +} + +TEST(AdaptiveCpuStatsTest, failedRun) { + std::unique_ptr timeSource = std::make_unique(); + + EXPECT_CALL(*timeSource, GetTime()) + .Times(4) + .WillOnce(Return(1000ns)) + .WillOnce(Return(1100ns)) + .WillOnce(Return(1200ns)) + .WillOnce(Return(1300ns)); + + AdaptiveCpuStats stats(std::move(timeSource)); + stats.RegisterStartRun(); + stats.RegisterStartRun(); + stats.RegisterSuccessfulRun(ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_60, {}, + AdaptiveCpuConfig::DEFAULT); + + std::stringstream stream; + stats.DumpToStream(stream); + EXPECT_THAT(stream.str(), HasSubstr("- Successful runs / total runs: 1 / 2\n")); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/CpuFrequencyReaderTest.cpp b/power-libperfmgr/adaptivecpu/tests/CpuFrequencyReaderTest.cpp new file mode 100644 index 00000000..ea3e738d --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/CpuFrequencyReaderTest.cpp @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "adaptivecpu/CpuFrequencyReader.h" +#include "mocks.h" + +using testing::_; +using testing::ByMove; +using testing::Return; +using std::chrono_literals::operator""ms; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +std::ostream &operator<<(std::ostream &stream, const CpuPolicyAverageFrequency &frequency) { + return stream << "CpuPolicyAverageFrequency(" << frequency.policyId << ", " + << frequency.averageFrequencyHz << ")"; +} + +TEST(CpuFrequencyReaderTest, cpuPolicyIds) { + std::unique_ptr filesystem = std::make_unique(); + EXPECT_CALL(*filesystem, ListDirectory("/sys/devices/system/cpu/cpufreq", _)) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::vector{"ignored1", "policy1", "ignored2", + "policy5", "policy10", "policybad"}; + return true; + }); + EXPECT_CALL(*filesystem, ReadFileStream(_, _)) + .WillRepeatedly([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1 2\n3 4\n"); + return true; + }); + + CpuFrequencyReader reader(std::move(filesystem)); + EXPECT_TRUE(reader.Init()); + + std::map> expected = { + {1, {{1, 20ms}, {3, 40ms}}}, {5, {{1, 20ms}, {3, 40ms}}}, {10, {{1, 20ms}, {3, 40ms}}}}; + EXPECT_EQ(reader.GetPreviousCpuPolicyFrequencies(), expected); +} + +TEST(CpuFrequencyReaderTest, getRecentCpuPolicyFrequencies) { + std::unique_ptr filesystem = std::make_unique(); + EXPECT_CALL(*filesystem, ListDirectory("/sys/devices/system/cpu/cpufreq", _)) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::vector{"policy1", "policy2"}; + return true; + }); + EXPECT_CALL(*filesystem, + ReadFileStream("/sys/devices/system/cpu/cpufreq/policy1/stats/time_in_state", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1000 5\n2000 4"); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1000 7\n2000 10"); + return true; + }); + EXPECT_CALL(*filesystem, + ReadFileStream("/sys/devices/system/cpu/cpufreq/policy2/stats/time_in_state", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1500 1\n2500 23"); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1500 5\n2500 23"); + return true; + }); + + CpuFrequencyReader reader(std::move(filesystem)); + EXPECT_TRUE(reader.Init()); + + std::vector actual; + EXPECT_TRUE(reader.GetRecentCpuPolicyFrequencies(&actual)); + EXPECT_EQ(actual, std::vector({ + {.policyId = 1, .averageFrequencyHz = 1750}, + {.policyId = 2, .averageFrequencyHz = 1500}, + })); +} + +TEST(CpuFrequencyReaderTest, getRecentCpuPolicyFrequencies_frequenciesChange) { + std::unique_ptr filesystem = std::make_unique(); + EXPECT_CALL(*filesystem, ListDirectory("/sys/devices/system/cpu/cpufreq", _)) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::vector{"policy1"}; + return true; + }); + EXPECT_CALL(*filesystem, + ReadFileStream("/sys/devices/system/cpu/cpufreq/policy1/stats/time_in_state", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1000 5\n2000 4"); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1000 6\n2001 4"); + return true; + }); + + CpuFrequencyReader reader(std::move(filesystem)); + EXPECT_TRUE(reader.Init()); + + std::vector actual; + EXPECT_FALSE(reader.GetRecentCpuPolicyFrequencies(&actual)); +} + +TEST(CpuFrequencyReaderTest, getRecentCpuPolicyFrequencies_badFormat) { + std::unique_ptr filesystem = std::make_unique(); + EXPECT_CALL(*filesystem, ListDirectory("/sys/devices/system/cpu/cpufreq", _)) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::vector{"policy1"}; + return true; + }); + EXPECT_CALL(*filesystem, + ReadFileStream("/sys/devices/system/cpu/cpufreq/policy1/stats/time_in_state", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1000 1"); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1000 2\nfoo"); + return true; + }); + + CpuFrequencyReader reader(std::move(filesystem)); + EXPECT_TRUE(reader.Init()); + + std::vector actual; + EXPECT_FALSE(reader.GetRecentCpuPolicyFrequencies(&actual)); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderProcStatTest.cpp b/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderProcStatTest.cpp new file mode 100644 index 00000000..a090fc22 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderProcStatTest.cpp @@ -0,0 +1,139 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "adaptivecpu/CpuLoadReaderProcStat.h" +#include "mocks.h" + +#define LOG_TAG "powerhal-adaptivecpu" + +using testing::_; +using testing::ByMove; +using testing::Return; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +TEST(CpuLoadReaderProcStatTest, GetRecentCpuLoads) { + std::unique_ptr filesystem = std::make_unique(); + EXPECT_CALL(*filesystem, ReadFileStream("/proc/stat", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + std::stringstream ss; + ss << "bad line\n"; + ss << "cpu1 100 0 0 50 0 0 0 0 0 0\n"; + ss << "cpu2 200 0 0 50 0 0 0 0 0 0\n"; + *result = std::make_unique(ss.str()); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + std::stringstream ss; + ss << "bad line\n"; + ss << "cpu1 200 0 0 150 0 0 0 0 0 0\n"; + ss << "cpu2 500 0 0 150 0 0 0 0 0 0\n"; + *result = std::make_unique(ss.str()); + return true; + }); + + CpuLoadReaderProcStat reader(std::move(filesystem)); + reader.Init(); + + std::array actualPercentages; + ASSERT_TRUE(reader.GetRecentCpuLoads(&actualPercentages)); + std::array expectedPercentages({0, 0.5, 0.25, 0, 0, 0, 0, 0}); + ASSERT_EQ(actualPercentages, expectedPercentages); +} + +TEST(CpuLoadReaderProcStatTest, GetRecentCpuLoads_failsWithMissingValues) { + std::unique_ptr filesystem = std::make_unique(); + EXPECT_CALL(*filesystem, ReadFileStream("/proc/stat", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + std::stringstream ss; + ss << "bad line\n"; + ss << "cpu1 100 0 0 50 0 0 0\n"; + ss << "cpu2 200 0 0 50 0 0 0\n"; + *result = std::make_unique(ss.str()); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + std::stringstream ss; + ss << "bad line\n"; + ss << "cpu1 200 0 0 150 0 0 0\n"; + ss << "cpu2 500 0 0 150 0 0 0\n"; + *result = std::make_unique(ss.str()); + return true; + }); + + CpuLoadReaderProcStat reader(std::move(filesystem)); + reader.Init(); + std::array actualPercentages; + ASSERT_FALSE(reader.GetRecentCpuLoads(&actualPercentages)); +} + +TEST(CpuLoadReaderProcStatTest, GetRecentCpuLoads_failsWithEmptyFile) { + std::unique_ptr filesystem = std::make_unique(); + EXPECT_CALL(*filesystem, ReadFileStream("/proc/stat", _)) + .Times(2) + .WillRepeatedly([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique(""); + return true; + }); + + CpuLoadReaderProcStat reader(std::move(filesystem)); + reader.Init(); + std::array actualPercentages; + ASSERT_FALSE(reader.GetRecentCpuLoads(&actualPercentages)); +} + +TEST(CpuLoadReaderProcStatTest, GetRecentCpuLoads_failsWithDifferentCpus) { + std::unique_ptr filesystem = std::make_unique(); + EXPECT_CALL(*filesystem, ReadFileStream("/proc/stat", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + std::stringstream ss; + ss << "bad line\n"; + ss << "cpu1 100 0 0 50 0 0 0 0 0 0\n"; + ss << "cpu2 200 0 0 50 0 0 0 0 0 0\n"; + *result = std::make_unique(ss.str()); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + std::stringstream ss; + ss << "bad line\n"; + ss << "cpu1 200 0 0 150 0 0 0 0 0 0\n"; + ss << "cpu3 500 0 0 150 0 0 0 0 0 0\n"; + *result = std::make_unique(ss.str()); + return true; + }); + + CpuLoadReaderProcStat reader(std::move(filesystem)); + reader.Init(); + std::array actualPercentages; + ASSERT_FALSE(reader.GetRecentCpuLoads(&actualPercentages)); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderSysDevicesTest.cpp b/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderSysDevicesTest.cpp new file mode 100644 index 00000000..a860d789 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderSysDevicesTest.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "adaptivecpu/CpuLoadReaderSysDevices.h" +#include "mocks.h" + +#define LOG_TAG "powerhal-adaptivecpu" + +using testing::_; +using testing::ByMove; +using testing::MatchesRegex; +using testing::Return; +using std::chrono_literals::operator""ms; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +TEST(CpuLoadReaderSysDevicesTest, GetRecentCpuLoads) { + std::unique_ptr filesystem = std::make_unique(); + std::unique_ptr timeSource = std::make_unique(); + EXPECT_CALL(*filesystem, ListDirectory(MatchesRegex("/sys/devices/system/cpu/cpu0/cpuidle"), _)) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::vector{"foo", "bar", "baz"}; + return true; + }); + EXPECT_CALL(*filesystem, + ListDirectory(MatchesRegex("/sys/devices/system/cpu/cpu0/cpuidle/(foo|bar)"), _)) + .Times(2) + .WillRepeatedly([](auto _path __attribute__((unused)), auto result) { + *result = std::vector{"abc", "time", "xyz"}; + return true; + }); + EXPECT_CALL(*filesystem, + ListDirectory(MatchesRegex("/sys/devices/system/cpu/cpu0/cpuidle/baz"), _)) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::vector{"abc", "xyz"}; + return true; + }); + + EXPECT_CALL(*filesystem, ReadFileStream("/sys/devices/system/cpu/cpu0/cpuidle/foo/time", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("100"); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("200"); + return true; + }); + EXPECT_CALL(*filesystem, ReadFileStream("/sys/devices/system/cpu/cpu0/cpuidle/bar/time", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("500"); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("700"); + return true; + }); + + EXPECT_CALL(*filesystem, ReadFileStream("/sys/devices/system/cpu/cpu1/cpuidle/foo/time", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1000"); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("1010"); + return true; + }); + EXPECT_CALL(*filesystem, ReadFileStream("/sys/devices/system/cpu/cpu1/cpuidle/bar/time", _)) + .Times(2) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("50"); + return true; + }) + .WillOnce([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("70"); + return true; + }); + + EXPECT_CALL(*filesystem, + ReadFileStream( + MatchesRegex("/sys/devices/system/cpu/cpu[2-7]/cpuidle/(foo|bar)/time"), _)) + .WillRepeatedly([](auto _path __attribute__((unused)), auto result) { + *result = std::make_unique("0"); + return true; + }); + + EXPECT_CALL(*timeSource, GetTime()).Times(2).WillOnce(Return(1ms)).WillOnce(Return(2ms)); + + CpuLoadReaderSysDevices reader(std::move(filesystem), std::move(timeSource)); + ASSERT_TRUE(reader.Init()); + + std::array actualPercentage; + reader.GetRecentCpuLoads(&actualPercentage); + + std::array expectedPercentage{0.3, 0.03, 0, 0, 0, 0, 0, 0}; + ASSERT_EQ(actualPercentage, expectedPercentage); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/KernelCpuFeatureReaderTest.cpp b/power-libperfmgr/adaptivecpu/tests/KernelCpuFeatureReaderTest.cpp new file mode 100644 index 00000000..9e0ba030 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/KernelCpuFeatureReaderTest.cpp @@ -0,0 +1,211 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "adaptivecpu/KernelCpuFeatureReader.h" +#include "mocks.h" + +using testing::_; +using testing::ByMove; +using testing::MatchesRegex; +using testing::Return; +using std::chrono_literals::operator""ns; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +TEST(KernelCpuFeatureReaderTest, valid) { + std::unique_ptr filesystem = std::make_unique(); + std::unique_ptr timeSource = std::make_unique(); + + EXPECT_CALL(*timeSource, GetKernelTime()) + .Times(2) + .WillOnce(Return(100ns)) + .WillOnce(Return(200ns)); + + EXPECT_CALL(*filesystem, ReadFileStream("/proc/vendor_sched/acpu_stats", _)) + .WillOnce([](auto path __attribute__((unused)), auto result) { + // Empty file, we will populate in ResetFileStream. + *result = std::make_unique(""); + return true; + }); + + EXPECT_CALL(*filesystem, ResetFileStream(_)) + .Times(2) + .WillOnce([](auto &result) { + std::array acpuStats{{ + {.weighted_sum_freq = 100, .total_idle_time_ns = 100}, + {.weighted_sum_freq = 100, .total_idle_time_ns = 100}, + {.weighted_sum_freq = 100, .total_idle_time_ns = 100}, + {.weighted_sum_freq = 100, .total_idle_time_ns = 100}, + {.weighted_sum_freq = 200, .total_idle_time_ns = 200}, + {.weighted_sum_freq = 200, .total_idle_time_ns = 200}, + {.weighted_sum_freq = 300, .total_idle_time_ns = 200}, + {.weighted_sum_freq = 300, .total_idle_time_ns = 200}, + }}; + char *bytes = reinterpret_cast(acpuStats.begin()); + static_cast(*result).str( + std::string(bytes, bytes + sizeof(acpuStats))); + return true; + }) + .WillOnce([](auto &result) { + std::array acpuStats{{ + {.weighted_sum_freq = 200, .total_idle_time_ns = 150}, + {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, + {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, + {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, + {.weighted_sum_freq = 300, .total_idle_time_ns = 300}, + {.weighted_sum_freq = 200, .total_idle_time_ns = 300}, + {.weighted_sum_freq = 400, .total_idle_time_ns = 300}, + {.weighted_sum_freq = 300, .total_idle_time_ns = 300}, + }}; + char *bytes = reinterpret_cast(acpuStats.begin()); + static_cast(*result).str( + std::string(bytes, bytes + sizeof(acpuStats))); + return true; + }); + + KernelCpuFeatureReader reader(std::move(filesystem), std::move(timeSource)); + ASSERT_TRUE(reader.Init()); + + std::array cpuPolicyAverageFrequencyHz; + std::array cpuCoreIdleTimesPercentage; + ASSERT_TRUE( + reader.GetRecentCpuFeatures(&cpuPolicyAverageFrequencyHz, &cpuCoreIdleTimesPercentage)); + std::array expectedFrequencies{{1, 1, 1}}; + std::array expectedIdleTimes{{0.5, 0.5, 0.5, 0.5, 1, 1, 1, 1}}; + ASSERT_EQ(cpuPolicyAverageFrequencyHz, expectedFrequencies); + ASSERT_EQ(cpuCoreIdleTimesPercentage, expectedIdleTimes); +} + +TEST(KernelCpuFeatureReaderTest, noFile) { + std::unique_ptr filesystem = std::make_unique(); + std::unique_ptr timeSource = std::make_unique(); + + EXPECT_CALL(*filesystem, ReadFileStream("/proc/vendor_sched/acpu_stats", _)) + .WillOnce(Return(false)); + + KernelCpuFeatureReader reader(std::move(filesystem), std::move(timeSource)); + ASSERT_FALSE(reader.Init()); +} + +TEST(KernelCpuFeatureReaderTest, frequencies_capsNegativeDiff) { + std::unique_ptr filesystem = std::make_unique(); + std::unique_ptr timeSource = std::make_unique(); + + EXPECT_CALL(*timeSource, GetKernelTime()) + .Times(2) + .WillOnce(Return(100ns)) + .WillOnce(Return(200ns)); + + EXPECT_CALL(*filesystem, ReadFileStream("/proc/vendor_sched/acpu_stats", _)) + .WillOnce([](auto path __attribute__((unused)), auto result) { + // Empty file, we will populate in ResetFileStream. + *result = std::make_unique(""); + return true; + }); + + EXPECT_CALL(*filesystem, ResetFileStream(_)) + .Times(2) + .WillOnce([](auto &result) { + std::array acpuStats{{ + {.weighted_sum_freq = 200, .total_idle_time_ns = 100}, + }}; + char *bytes = reinterpret_cast(acpuStats.begin()); + static_cast(*result).str( + std::string(bytes, bytes + sizeof(acpuStats))); + return true; + }) + .WillOnce([](auto &result) { + std::array acpuStats{{ + {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, + }}; + char *bytes = reinterpret_cast(acpuStats.begin()); + static_cast(*result).str( + std::string(bytes, bytes + sizeof(acpuStats))); + return true; + }); + + KernelCpuFeatureReader reader(std::move(filesystem), std::move(timeSource)); + ASSERT_TRUE(reader.Init()); + + std::array cpuPolicyAverageFrequencyHz; + std::array cpuCoreIdleTimesPercentage; + ASSERT_TRUE( + reader.GetRecentCpuFeatures(&cpuPolicyAverageFrequencyHz, &cpuCoreIdleTimesPercentage)); + std::array expectedFrequencies{{0}}; + ASSERT_EQ(cpuPolicyAverageFrequencyHz, expectedFrequencies); +} + +TEST(KernelCpuFeatureReaderTest, idleTimes_capsNegativeDiff) { + std::unique_ptr filesystem = std::make_unique(); + std::unique_ptr timeSource = std::make_unique(); + + EXPECT_CALL(*timeSource, GetKernelTime()) + .Times(2) + .WillOnce(Return(100ns)) + .WillOnce(Return(200ns)); + + EXPECT_CALL(*filesystem, ReadFileStream("/proc/vendor_sched/acpu_stats", _)) + .WillOnce([](auto path __attribute__((unused)), auto result) { + // Empty file, we will populate in ResetFileStream. + *result = std::make_unique(""); + return true; + }); + + EXPECT_CALL(*filesystem, ResetFileStream(_)) + .Times(2) + .WillOnce([](auto &result) { + std::array acpuStats{{ + {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, + }}; + char *bytes = reinterpret_cast(acpuStats.begin()); + static_cast(*result).str( + std::string(bytes, bytes + sizeof(acpuStats))); + return true; + }) + .WillOnce([](auto &result) { + std::array acpuStats{{ + {.weighted_sum_freq = 200, .total_idle_time_ns = 100}, + }}; + char *bytes = reinterpret_cast(acpuStats.begin()); + static_cast(*result).str( + std::string(bytes, bytes + sizeof(acpuStats))); + return true; + }); + + KernelCpuFeatureReader reader(std::move(filesystem), std::move(timeSource)); + ASSERT_TRUE(reader.Init()); + + std::array cpuPolicyAverageFrequencyHz; + std::array cpuCoreIdleTimesPercentage; + ASSERT_TRUE( + reader.GetRecentCpuFeatures(&cpuPolicyAverageFrequencyHz, &cpuCoreIdleTimesPercentage)); + std::array expectedIdleTimes{{0}}; + ASSERT_EQ(cpuCoreIdleTimesPercentage, expectedIdleTimes); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/ModelTest.cpp b/power-libperfmgr/adaptivecpu/tests/ModelTest.cpp new file mode 100644 index 00000000..593725e6 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/ModelTest.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include +#include + +#include "adaptivecpu/Model.h" +#include "mocks.h" + +using std::chrono_literals::operator""ns; +using testing::_; +using testing::ByMove; +using testing::Return; +using testing::UnorderedElementsAre; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +TEST(ModelTest, ModelInput_SetCpuFreqiencies) { + const ModelInput expected{ + .cpuPolicyAverageFrequencyHz = {100, 101, 102}, + }; + ModelInput actual; + ASSERT_TRUE(actual.SetCpuFreqiencies({ + {.policyId = 0, .averageFrequencyHz = 100}, + {.policyId = 4, .averageFrequencyHz = 101}, + {.policyId = 6, .averageFrequencyHz = 102}, + })); + ASSERT_EQ(actual, expected); +} + +TEST(ModelTest, ModelInput_SetCpuFreqiencies_failsWithOutOfOrderFrquencies) { + ASSERT_FALSE(ModelInput().SetCpuFreqiencies({ + {.policyId = 0, .averageFrequencyHz = 100}, + {.policyId = 6, .averageFrequencyHz = 102}, + {.policyId = 4, .averageFrequencyHz = 101}, + })); +} + +TEST(ModelTest, Run_randomInputs) { + std::default_random_engine generator; + std::uniform_real_distribution frequencyDistribution(0, 1e6); + std::uniform_real_distribution idleTimesDistribution(0, 1); + std::uniform_int_distribution frameTimeDistribution(1, 100); + std::uniform_int_distribution numRenderedFramesDistribution(1, 20); + std::uniform_int_distribution throttleDecisionDistribution(0, 3); + + const auto randomModelInput = [&]() { + return ModelInput{ + .cpuPolicyAverageFrequencyHz = {frequencyDistribution(generator), + frequencyDistribution(generator), + frequencyDistribution(generator)}, + .cpuCoreIdleTimesPercentage = + {idleTimesDistribution(generator), idleTimesDistribution(generator), + idleTimesDistribution(generator), idleTimesDistribution(generator), + idleTimesDistribution(generator), idleTimesDistribution(generator), + idleTimesDistribution(generator), idleTimesDistribution(generator)}, + .workDurationFeatures = + {.averageDuration = + std::chrono::nanoseconds(frameTimeDistribution(generator)), + .maxDuration = std::chrono::nanoseconds(frameTimeDistribution(generator)), + .numMissedDeadlines = numRenderedFramesDistribution(generator), + .numDurations = numRenderedFramesDistribution(generator)}, + .previousThrottleDecision = + static_cast(throttleDecisionDistribution(generator)), + }; + }; + + for (int i = 0; i < 10; i++) { + std::deque modelInputs{randomModelInput(), randomModelInput(), + randomModelInput()}; + Model().Run(modelInputs, AdaptiveCpuConfig::DEFAULT); + } +} + +TEST(ModelTest, Run_randomThrottling) { + ModelInput modelInput{ + .cpuPolicyAverageFrequencyHz = {0, 0, 0}, + .cpuCoreIdleTimesPercentage = {0, 0, 0, 0, 0, 0, 0, 0}, + .workDurationFeatures = {.averageDuration = 0ns, + .maxDuration = 0ns, + .numMissedDeadlines = 0, + .numDurations = 0}, + .previousThrottleDecision = ThrottleDecision::NO_THROTTLE, + }; + std::deque modelInputs{modelInput, modelInput, modelInput}; + + AdaptiveCpuConfig config = AdaptiveCpuConfig::DEFAULT; + config.randomThrottleOptions = {ThrottleDecision::THROTTLE_70, ThrottleDecision::THROTTLE_80}; + config.randomThrottleDecisionProbability = 1; + + std::set actualThrottleDecisions; + Model model; + for (int i = 0; i < 100; i++) { + ThrottleDecision throttleDecision = model.Run(modelInputs, config); + actualThrottleDecisions.insert(throttleDecision); + } + ASSERT_THAT(actualThrottleDecisions, + UnorderedElementsAre(ThrottleDecision::THROTTLE_70, ThrottleDecision::THROTTLE_80)); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/WorkDurationProcessorTest.cpp b/power-libperfmgr/adaptivecpu/tests/WorkDurationProcessorTest.cpp new file mode 100644 index 00000000..5699a219 --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/WorkDurationProcessorTest.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "adaptivecpu/WorkDurationProcessor.h" + +using ::aidl::android::hardware::power::WorkDuration; +using std::chrono_literals::operator""ns; + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +static const std::chrono::nanoseconds kNormalTargetDuration = 16666666ns; + +TEST(WorkDurationProcessorTest, GetFeatures) { + WorkDurationProcessor processor; + ASSERT_TRUE(processor.ReportWorkDurations( + std::vector{ + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}, + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 3}}, + kNormalTargetDuration)); + + const WorkDurationFeatures expected = {.averageDuration = kNormalTargetDuration * 2, + .maxDuration = kNormalTargetDuration * 3, + .numMissedDeadlines = 1, + .numDurations = 2}; + const WorkDurationFeatures actual = processor.GetFeatures(); + ASSERT_EQ(actual, expected); +} + +TEST(WorkDurationProcessorTest, GetFeatures_multipleBatches) { + WorkDurationProcessor processor; + ASSERT_TRUE(processor.ReportWorkDurations( + std::vector{ + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}, + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 3}}, + kNormalTargetDuration)); + ASSERT_TRUE(processor.ReportWorkDurations( + std::vector{ + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 6}, + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 2}}, + kNormalTargetDuration)); + + const WorkDurationFeatures expected = {.averageDuration = kNormalTargetDuration * 3, + .maxDuration = kNormalTargetDuration * 6, + .numMissedDeadlines = 3, + .numDurations = 4}; + const WorkDurationFeatures actual = processor.GetFeatures(); + ASSERT_EQ(actual, expected); +} + +TEST(WorkDurationProcessorTest, GetFeatures_scalesDifferentTargetDurations) { + WorkDurationProcessor processor; + ASSERT_TRUE(processor.ReportWorkDurations( + std::vector{ + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 2}, + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 6}}, + kNormalTargetDuration * 2)); + + const WorkDurationFeatures expected = {.averageDuration = kNormalTargetDuration * 2, + .maxDuration = kNormalTargetDuration * 3, + .numMissedDeadlines = 1, + .numDurations = 2}; + const WorkDurationFeatures actual = processor.GetFeatures(); + ASSERT_EQ(actual, expected); +} + +TEST(WorkDurationProcessorTest, GetFeatures_noFrames) { + WorkDurationProcessor processor; + const WorkDurationFeatures expected = { + .averageDuration = 0ns, .maxDuration = 0ns, .numMissedDeadlines = 0, .numDurations = 0}; + const WorkDurationFeatures actual = processor.GetFeatures(); + ASSERT_EQ(actual, expected); +} + +TEST(WorkDurationProcessorTest, HasWorkDurations) { + WorkDurationProcessor processor; + ASSERT_FALSE(processor.HasWorkDurations()); + ASSERT_TRUE(processor.ReportWorkDurations( + std::vector{ + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}}, + kNormalTargetDuration * 2)); + ASSERT_TRUE(processor.HasWorkDurations()); + processor.GetFeatures(); + ASSERT_FALSE(processor.HasWorkDurations()); +} + +TEST(WorkDurationProcessorTest, GetFeatures_tooManyUnprocessedThenClears) { + WorkDurationProcessor processor; + for (int i = 0; i < 1000; i++) { + ASSERT_TRUE(processor.ReportWorkDurations( + std::vector{ + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}}, + kNormalTargetDuration)); + } + ASSERT_FALSE(processor.ReportWorkDurations( + std::vector{ + {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}}, + kNormalTargetDuration)); + ASSERT_EQ(processor.GetFeatures().numDurations, 0); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/mocks.h b/power-libperfmgr/adaptivecpu/tests/mocks.h new file mode 100644 index 00000000..c7a4983b --- /dev/null +++ b/power-libperfmgr/adaptivecpu/tests/mocks.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "adaptivecpu/IFilesystem.h" +#include "adaptivecpu/ITimeSource.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +class MockFilesystem : public IFilesystem { + public: + ~MockFilesystem() override {} + MOCK_METHOD(bool, ListDirectory, (const std::string &path, std::vector *result), + (const, override)); + MOCK_METHOD(bool, ReadFileStream, + (const std::string &path, std::unique_ptr *result), + (const, override)); + MOCK_METHOD(bool, ResetFileStream, (const std::unique_ptr &fileStream), + (const, override)); +}; + +class MockTimeSource : public ITimeSource { + public: + ~MockTimeSource() override {} + MOCK_METHOD(std::chrono::nanoseconds, GetTime, (), (const, override)); + MOCK_METHOD(std::chrono::nanoseconds, GetKernelTime, (), (const, override)); +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/Power.cpp b/power-libperfmgr/aidl/Power.cpp new file mode 100644 index 00000000..18fd25e3 --- /dev/null +++ b/power-libperfmgr/aidl/Power.cpp @@ -0,0 +1,216 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-libperfmgr" + +#include "Power.h" + +#include +#include +#include +#include +#include +#include + +#include + +#include "PowerHintSession.h" +#include "PowerSessionManager.h" + +#ifndef TAP_TO_WAKE_NODE +#define TAP_TO_WAKE_NODE "/sys/touchpanel/double_tap" +#endif + +#ifndef TAP_TO_WAKE_NODE2 +#define TAP_TO_WAKE_NODE2 "/proc/touchscreen/enable_dt2w" +#endif + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using ::aidl::google::hardware::power::impl::pixel::PowerHintSession; +using ::android::perfmgr::HintManager; + +constexpr char kPowerHalStateProp[] = "vendor.powerhal.state"; +constexpr char kPowerHalRenderingProp[] = "vendor.powerhal.rendering"; + +Power::Power(std::shared_ptr adaptiveCpu) + : mAdaptiveCpu(adaptiveCpu), + mInteractionHandler(nullptr), + mSustainedPerfModeOn(false) { + mInteractionHandler = std::make_unique(); + mInteractionHandler->Init(); + + std::string state = ::android::base::GetProperty(kPowerHalStateProp, ""); + if (state == "SUSTAINED_PERFORMANCE") { + LOG(INFO) << "Initialize with SUSTAINED_PERFORMANCE on"; + HintManager::GetInstance()->DoHint("SUSTAINED_PERFORMANCE"); + mSustainedPerfModeOn = true; + } else { + LOG(INFO) << "Initialize PowerHAL"; + } + + state = ::android::base::GetProperty(kPowerHalRenderingProp, ""); + if (state == "EXPENSIVE_RENDERING") { + LOG(INFO) << "Initialize with EXPENSIVE_RENDERING on"; + HintManager::GetInstance()->DoHint("EXPENSIVE_RENDERING"); + } +} + +ndk::ScopedAStatus Power::setMode(Mode type, bool enabled) { + LOG(DEBUG) << "Power setMode: " << toString(type) << " to: " << enabled; + if (HintManager::GetInstance()->GetAdpfProfile() && + HintManager::GetInstance()->GetAdpfProfile()->mReportingRateLimitNs > 0) { + PowerSessionManager::getInstance()->updateHintMode(toString(type), enabled); + } + switch (type) { + case Mode::DOUBLE_TAP_TO_WAKE: + { + ::android::base::WriteStringToFile(enabled ? "1" : "0", TAP_TO_WAKE_NODE, true); + ::android::base::WriteStringToFile(enabled ? "1" : "0", TAP_TO_WAKE_NODE2, true); + [[fallthrough]]; + } + case Mode::LOW_POWER: + break; + case Mode::SUSTAINED_PERFORMANCE: + if (enabled) { + HintManager::GetInstance()->DoHint("SUSTAINED_PERFORMANCE"); + } + mSustainedPerfModeOn = true; + break; + case Mode::LAUNCH: + if (mSustainedPerfModeOn) { + break; + } + [[fallthrough]]; + case Mode::FIXED_PERFORMANCE: + [[fallthrough]]; + case Mode::EXPENSIVE_RENDERING: + [[fallthrough]]; + case Mode::INTERACTIVE: + [[fallthrough]]; + case Mode::DEVICE_IDLE: + [[fallthrough]]; + case Mode::DISPLAY_INACTIVE: + [[fallthrough]]; + case Mode::GAME_LOADING: + [[fallthrough]]; + default: + if (enabled) { + HintManager::GetInstance()->DoHint(toString(type)); + } else { + HintManager::GetInstance()->EndHint(toString(type)); + } + break; + } + + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus Power::isModeSupported(Mode type, bool *_aidl_return) { + bool supported = HintManager::GetInstance()->IsHintSupported(toString(type)); + // LOW_POWER and DOUBLE_TAP_TO_WAKE handled insides PowerHAL specifically + if (type == Mode::LOW_POWER || type == Mode::DOUBLE_TAP_TO_WAKE) { + supported = true; + } + LOG(INFO) << "Power mode " << toString(type) << " isModeSupported: " << supported; + *_aidl_return = supported; + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) { + LOG(DEBUG) << "Power setBoost: " << toString(type) << " duration: " << durationMs; + if (HintManager::GetInstance()->GetAdpfProfile() && + HintManager::GetInstance()->GetAdpfProfile()->mReportingRateLimitNs > 0) { + PowerSessionManager::getInstance()->updateHintBoost(toString(type), durationMs); + } + switch (type) { + case Boost::INTERACTION: + if (mSustainedPerfModeOn) { + break; + } + mInteractionHandler->Acquire(durationMs); + break; + case Boost::DISPLAY_UPDATE_IMMINENT: + [[fallthrough]]; + case Boost::ML_ACC: + [[fallthrough]]; + default: + if (mSustainedPerfModeOn) { + break; + } + if (durationMs > 0) { + HintManager::GetInstance()->DoHint(toString(type), + std::chrono::milliseconds(durationMs)); + } else if (durationMs == 0) { + HintManager::GetInstance()->DoHint(toString(type)); + } else { + HintManager::GetInstance()->EndHint(toString(type)); + } + break; + } + + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus Power::isBoostSupported(Boost type, bool *_aidl_return) { + bool supported = HintManager::GetInstance()->IsHintSupported(toString(type)); + LOG(INFO) << "Power boost " << toString(type) << " isBoostSupported: " << supported; + *_aidl_return = supported; + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus Power::createHintSession(int32_t tgid, int32_t uid, + const std::vector &threadIds, + int64_t durationNanos, + std::shared_ptr *_aidl_return) { + if (!HintManager::GetInstance()->GetAdpfProfile() || + HintManager::GetInstance()->GetAdpfProfile()->mReportingRateLimitNs <= 0) { + *_aidl_return = nullptr; + return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); + } + if (threadIds.size() == 0) { + LOG(ERROR) << "Error: threadIds.size() shouldn't be " << threadIds.size(); + *_aidl_return = nullptr; + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } + std::shared_ptr session = ndk::SharedRefBase::make( + mAdaptiveCpu, tgid, uid, threadIds, durationNanos); + *_aidl_return = session; + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus Power::getHintSessionPreferredRate(int64_t *outNanoseconds) { + *outNanoseconds = HintManager::GetInstance()->GetAdpfProfile() + ? HintManager::GetInstance()->GetAdpfProfile()->mReportingRateLimitNs + : 0; + if (*outNanoseconds <= 0) { + return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); + } + + return ndk::ScopedAStatus::ok(); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/Power.h b/power-libperfmgr/aidl/Power.h new file mode 100644 index 00000000..c8321d8f --- /dev/null +++ b/power-libperfmgr/aidl/Power.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +#include +#include +#include + +#include "adaptivecpu/AdaptiveCpu.h" +#include "disp-power/InteractionHandler.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using ::aidl::android::hardware::power::Boost; +using ::aidl::android::hardware::power::IPowerHintSession; +using ::aidl::android::hardware::power::Mode; + +class Power : public ::aidl::android::hardware::power::BnPower { + public: + Power(std::shared_ptr adaptiveCpu); + ndk::ScopedAStatus setMode(Mode type, bool enabled) override; + ndk::ScopedAStatus isModeSupported(Mode type, bool *_aidl_return) override; + ndk::ScopedAStatus setBoost(Boost type, int32_t durationMs) override; + ndk::ScopedAStatus isBoostSupported(Boost type, bool *_aidl_return) override; + ndk::ScopedAStatus createHintSession(int32_t tgid, int32_t uid, + const std::vector &threadIds, + int64_t durationNanos, + std::shared_ptr *_aidl_return) override; + ndk::ScopedAStatus getHintSessionPreferredRate(int64_t *outNanoseconds) override; + + private: + std::shared_ptr mAdaptiveCpu; + std::unique_ptr mInteractionHandler; + std::atomic mSustainedPerfModeOn; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/PowerExt.cpp b/power-libperfmgr/aidl/PowerExt.cpp new file mode 100644 index 00000000..1d91d9b2 --- /dev/null +++ b/power-libperfmgr/aidl/PowerExt.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "android.hardware.power-service.pixel.ext-libperfmgr" + +#include "PowerExt.h" + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "PowerSessionManager.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using ::android::perfmgr::HintManager; + +ndk::ScopedAStatus PowerExt::setMode(const std::string &mode, bool enabled) { + LOG(DEBUG) << "PowerExt setMode: " << mode << " to: " << enabled; + + if (enabled) { + HintManager::GetInstance()->DoHint(mode); + } else { + HintManager::GetInstance()->EndHint(mode); + } + if (HintManager::GetInstance()->GetAdpfProfile() && + HintManager::GetInstance()->GetAdpfProfile()->mReportingRateLimitNs > 0) { + PowerSessionManager::getInstance()->updateHintMode(mode, enabled); + } + + if (mode == AdaptiveCpu::HINT_NAME) { + LOG(DEBUG) << "AdaptiveCpu intercepted hint"; + mAdaptiveCpu->HintReceived(enabled); + } + + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus PowerExt::isModeSupported(const std::string &mode, bool *_aidl_return) { + bool supported = HintManager::GetInstance()->IsHintSupported(mode); + LOG(INFO) << "PowerExt mode " << mode << " isModeSupported: " << supported; + *_aidl_return = supported; + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus PowerExt::setBoost(const std::string &boost, int32_t durationMs) { + LOG(DEBUG) << "PowerExt setBoost: " << boost << " duration: " << durationMs; + if (HintManager::GetInstance()->GetAdpfProfile() && + HintManager::GetInstance()->GetAdpfProfile()->mReportingRateLimitNs > 0) { + PowerSessionManager::getInstance()->updateHintBoost(boost, durationMs); + } + + if (durationMs > 0) { + HintManager::GetInstance()->DoHint(boost, std::chrono::milliseconds(durationMs)); + } else if (durationMs == 0) { + HintManager::GetInstance()->DoHint(boost); + } else { + HintManager::GetInstance()->EndHint(boost); + } + + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus PowerExt::isBoostSupported(const std::string &boost, bool *_aidl_return) { + bool supported = HintManager::GetInstance()->IsHintSupported(boost); + LOG(INFO) << "PowerExt boost " << boost << " isBoostSupported: " << supported; + *_aidl_return = supported; + return ndk::ScopedAStatus::ok(); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/PowerExt.h b/power-libperfmgr/aidl/PowerExt.h new file mode 100644 index 00000000..da00d040 --- /dev/null +++ b/power-libperfmgr/aidl/PowerExt.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +#include +#include +#include + +#include "adaptivecpu/AdaptiveCpu.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +class PowerExt : public ::aidl::google::hardware::power::extension::pixel::BnPowerExt { + public: + PowerExt(std::shared_ptr acpu) + : mAdaptiveCpu(acpu) {} + ndk::ScopedAStatus setMode(const std::string &mode, bool enabled) override; + ndk::ScopedAStatus isModeSupported(const std::string &mode, bool *_aidl_return) override; + ndk::ScopedAStatus setBoost(const std::string &boost, int32_t durationMs) override; + ndk::ScopedAStatus isBoostSupported(const std::string &boost, bool *_aidl_return) override; + + private: + std::shared_ptr mAdaptiveCpu; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/PowerHintSession.cpp b/power-libperfmgr/aidl/PowerHintSession.cpp new file mode 100644 index 00000000..cac641a6 --- /dev/null +++ b/power-libperfmgr/aidl/PowerHintSession.cpp @@ -0,0 +1,596 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-libperfmgr" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "PowerHintSession.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "PowerSessionManager.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using ::android::base::StringPrintf; +using ::android::perfmgr::AdpfConfig; +using ::android::perfmgr::HintManager; +using std::chrono::duration_cast; +using std::chrono::nanoseconds; + +namespace { + +static inline int64_t ns_to_100us(int64_t ns) { + return ns / 100000; +} + +static int64_t convertWorkDurationToBoostByPid(std::shared_ptr adpfConfig, + nanoseconds targetDuration, + const std::vector &actualDurations, + int64_t *integral_error, int64_t *previous_error, + const std::string &idstr) { + uint64_t samplingWindowP = adpfConfig->mSamplingWindowP; + uint64_t samplingWindowI = adpfConfig->mSamplingWindowI; + uint64_t samplingWindowD = adpfConfig->mSamplingWindowD; + int64_t targetDurationNanos = (int64_t)targetDuration.count(); + int64_t length = actualDurations.size(); + int64_t p_start = + samplingWindowP == 0 || samplingWindowP > length ? 0 : length - samplingWindowP; + int64_t i_start = + samplingWindowI == 0 || samplingWindowI > length ? 0 : length - samplingWindowI; + int64_t d_start = + samplingWindowD == 0 || samplingWindowD > length ? 0 : length - samplingWindowD; + int64_t dt = ns_to_100us(targetDurationNanos); + int64_t err_sum = 0; + int64_t derivative_sum = 0; + for (int64_t i = std::min({p_start, i_start, d_start}); i < length; i++) { + int64_t actualDurationNanos = actualDurations[i].durationNanos; + if (std::abs(actualDurationNanos) > targetDurationNanos * 20) { + ALOGW("The actual duration is way far from the target (%" PRId64 " >> %" PRId64 ")", + actualDurationNanos, targetDurationNanos); + } + // PID control algorithm + int64_t error = ns_to_100us(actualDurationNanos - targetDurationNanos); + if (i >= d_start) { + derivative_sum += error - (*previous_error); + } + if (i >= p_start) { + err_sum += error; + } + if (i >= i_start) { + *integral_error = *integral_error + error * dt; + *integral_error = std::min(adpfConfig->getPidIHighDivI(), *integral_error); + *integral_error = std::max(adpfConfig->getPidILowDivI(), *integral_error); + } + *previous_error = error; + } + int64_t pOut = static_cast((err_sum > 0 ? adpfConfig->mPidPo : adpfConfig->mPidPu) * + err_sum / (length - p_start)); + int64_t iOut = static_cast(adpfConfig->mPidI * (*integral_error)); + int64_t dOut = + static_cast((derivative_sum > 0 ? adpfConfig->mPidDo : adpfConfig->mPidDu) * + derivative_sum / dt / (length - d_start)); + + int64_t output = pOut + iOut + dOut; + if (ATRACE_ENABLED()) { + std::string sz = StringPrintf("adpf.%s-pid.err", idstr.c_str()); + ATRACE_INT(sz.c_str(), err_sum / (length - p_start)); + sz = StringPrintf("adpf.%s-pid.integral", idstr.c_str()); + ATRACE_INT(sz.c_str(), *integral_error); + sz = StringPrintf("adpf.%s-pid.derivative", idstr.c_str()); + ATRACE_INT(sz.c_str(), derivative_sum / dt / (length - d_start)); + sz = StringPrintf("adpf.%s-pid.pOut", idstr.c_str()); + ATRACE_INT(sz.c_str(), pOut); + sz = StringPrintf("adpf.%s-pid.iOut", idstr.c_str()); + ATRACE_INT(sz.c_str(), iOut); + sz = StringPrintf("adpf.%s-pid.dOut", idstr.c_str()); + ATRACE_INT(sz.c_str(), dOut); + sz = StringPrintf("adpf.%s-pid.output", idstr.c_str()); + ATRACE_INT(sz.c_str(), output); + } + return output; +} + +} // namespace + +PowerHintSession::PowerHintSession(std::shared_ptr adaptiveCpu, int32_t tgid, + int32_t uid, const std::vector &threadIds, + int64_t durationNanos) + : mAdaptiveCpu(adaptiveCpu) { + mDescriptor = new AppHintDesc(tgid, uid, threadIds); + mDescriptor->duration = std::chrono::nanoseconds(durationNanos); + mStaleTimerHandler = sp(new StaleTimerHandler(this)); + mEarlyBoostHandler = sp(new EarlyBoostHandler(this)); + mPowerManagerHandler = PowerSessionManager::getInstance(); + mLastUpdatedTime.store(std::chrono::steady_clock::now()); + mLastStartedTimeNs = + std::chrono::duration_cast( + (std::chrono::steady_clock::now() - mDescriptor->duration).time_since_epoch()) + .count(); + mLastDurationNs = durationNanos; + mWorkPeriodNs = durationNanos; + + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-target", idstr.c_str()); + ATRACE_INT(sz.c_str(), (int64_t)mDescriptor->duration.count()); + sz = StringPrintf("adpf.%s-active", idstr.c_str()); + ATRACE_INT(sz.c_str(), mDescriptor->is_active.load()); + } + PowerSessionManager::getInstance()->addPowerSession(this); + // init boost + setSessionUclampMin(HintManager::GetInstance()->GetAdpfProfile()->mUclampMinInit); + ALOGV("PowerHintSession created: %s", mDescriptor->toString().c_str()); +} + +PowerHintSession::~PowerHintSession() { + close(); + ALOGV("PowerHintSession deleted: %s", mDescriptor->toString().c_str()); + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-target", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); + sz = StringPrintf("adpf.%s-actl_last", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); + sz = sz = StringPrintf("adpf.%s-active", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); + } + delete mDescriptor; +} + +std::string PowerHintSession::getIdString() const { + std::string idstr = StringPrintf("%" PRId32 "-%" PRId32 "-%" PRIxPTR, mDescriptor->tgid, + mDescriptor->uid, reinterpret_cast(this) & 0xffff); + return idstr; +} + +bool PowerHintSession::isAppSession() { + // Check if uid is in range reserved for applications + return mDescriptor->uid >= AID_APP_START; +} + +void PowerHintSession::updateUniveralBoostMode() { + if (!isAppSession()) { + return; + } + if (ATRACE_ENABLED()) { + const std::string tag = StringPrintf("%s:updateUniveralBoostMode()", getIdString().c_str()); + ATRACE_BEGIN(tag.c_str()); + } + PowerHintMonitor::getInstance()->getLooper()->sendMessage(mPowerManagerHandler, NULL); + if (ATRACE_ENABLED()) { + ATRACE_END(); + } +} + +int PowerHintSession::setSessionUclampMin(int32_t min) { + { + std::lock_guard guard(mSessionLock); + mDescriptor->current_min = min; + } + if (min) { + mStaleTimerHandler->updateTimer(); + } + PowerSessionManager::getInstance()->setUclampMin(this, min); + + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); + ATRACE_INT(sz.c_str(), min); + } + return 0; +} + +int PowerHintSession::getUclampMin() { + return mDescriptor->current_min; +} + +void PowerHintSession::dumpToStream(std::ostream &stream) { + stream << "ID.Min.Act.Timeout(" << getIdString(); + stream << ", " << mDescriptor->current_min; + stream << ", " << mDescriptor->is_active; + stream << ", " << isTimeout() << ")"; +} + +ndk::ScopedAStatus PowerHintSession::pause() { + if (mSessionClosed) { + ALOGE("Error: session is dead"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + if (!mDescriptor->is_active.load()) + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + // Reset to default uclamp value. + mDescriptor->is_active.store(false); + setStale(); + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-active", idstr.c_str()); + ATRACE_INT(sz.c_str(), mDescriptor->is_active.load()); + } + updateUniveralBoostMode(); + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus PowerHintSession::resume() { + if (mSessionClosed) { + ALOGE("Error: session is dead"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + if (mDescriptor->is_active.load()) + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + mDescriptor->is_active.store(true); + // resume boost + setSessionUclampMin(mDescriptor->current_min); + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-active", idstr.c_str()); + ATRACE_INT(sz.c_str(), mDescriptor->is_active.load()); + } + updateUniveralBoostMode(); + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus PowerHintSession::close() { + bool sessionClosedExpectedToBe = false; + if (!mSessionClosed.compare_exchange_strong(sessionClosedExpectedToBe, true)) { + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + // Remove the session from PowerSessionManager first to avoid racing. + PowerSessionManager::getInstance()->removePowerSession(this); + setSessionUclampMin(0); + { + std::lock_guard guard(mSessionLock); + mSessionClosed.store(true); + } + mDescriptor->is_active.store(false); + mEarlyBoostHandler->setSessionDead(); + mStaleTimerHandler->setSessionDead(); + updateUniveralBoostMode(); + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus PowerHintSession::updateTargetWorkDuration(int64_t targetDurationNanos) { + if (mSessionClosed) { + ALOGE("Error: session is dead"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + if (targetDurationNanos <= 0) { + ALOGE("Error: targetDurationNanos(%" PRId64 ") should bigger than 0", targetDurationNanos); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } + targetDurationNanos = + targetDurationNanos * HintManager::GetInstance()->GetAdpfProfile()->mTargetTimeFactor; + ALOGV("update target duration: %" PRId64 " ns", targetDurationNanos); + + mDescriptor->duration = std::chrono::nanoseconds(targetDurationNanos); + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-target", idstr.c_str()); + ATRACE_INT(sz.c_str(), (int64_t)mDescriptor->duration.count()); + } + + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus PowerHintSession::reportActualWorkDuration( + const std::vector &actualDurations) { + if (mSessionClosed) { + ALOGE("Error: session is dead"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + if (mDescriptor->duration.count() == 0LL) { + ALOGE("Expect to call updateTargetWorkDuration() first."); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + if (actualDurations.size() == 0) { + ALOGE("Error: duration.size() shouldn't be %zu.", actualDurations.size()); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } + if (!mDescriptor->is_active.load()) { + ALOGE("Error: shouldn't report duration during pause state."); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); + mDescriptor->update_count++; + bool isFirstFrame = isTimeout(); + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-batch_size", idstr.c_str()); + ATRACE_INT(sz.c_str(), actualDurations.size()); + sz = StringPrintf("adpf.%s-actl_last", idstr.c_str()); + ATRACE_INT(sz.c_str(), actualDurations.back().durationNanos); + sz = StringPrintf("adpf.%s-target", idstr.c_str()); + ATRACE_INT(sz.c_str(), (int64_t)mDescriptor->duration.count()); + sz = StringPrintf("adpf.%s-hint.count", idstr.c_str()); + ATRACE_INT(sz.c_str(), mDescriptor->update_count); + sz = StringPrintf("adpf.%s-hint.overtime", idstr.c_str()); + ATRACE_INT(sz.c_str(), + actualDurations.back().durationNanos - mDescriptor->duration.count() > 0); + } + + mLastUpdatedTime.store(std::chrono::steady_clock::now()); + if (isFirstFrame) { + updateUniveralBoostMode(); + } + + if (!adpfConfig->mPidOn) { + setSessionUclampMin(adpfConfig->mUclampMinHigh); + return ndk::ScopedAStatus::ok(); + } + int64_t output = convertWorkDurationToBoostByPid( + adpfConfig, mDescriptor->duration, actualDurations, &(mDescriptor->integral_error), + &(mDescriptor->previous_error), getIdString()); + + /* apply to all the threads in the group */ + int next_min = std::min(static_cast(adpfConfig->mUclampMinHigh), + mDescriptor->current_min + static_cast(output)); + next_min = std::max(static_cast(adpfConfig->mUclampMinLow), next_min); + setSessionUclampMin(next_min); + mStaleTimerHandler->updateTimer(getStaleTime()); + if (HintManager::GetInstance()->GetAdpfProfile()->mEarlyBoostOn) { + updateWorkPeriod(actualDurations); + mEarlyBoostHandler->updateTimer(getEarlyBoostTime()); + } + + mAdaptiveCpu->ReportWorkDurations(actualDurations, mDescriptor->duration); + + return ndk::ScopedAStatus::ok(); +} + +std::string AppHintDesc::toString() const { + std::string out = + StringPrintf("session %" PRIxPTR "\n", reinterpret_cast(this) & 0xffff); + const int64_t durationNanos = duration.count(); + out.append(StringPrintf(" duration: %" PRId64 " ns\n", durationNanos)); + out.append(StringPrintf(" uclamp.min: %d \n", current_min)); + out.append(StringPrintf(" uid: %d, tgid: %d\n", uid, tgid)); + + out.append(" threadIds: ["); + bool first = true; + for (int tid : threadIds) { + if (!first) { + out.append(", "); + } + out.append(std::to_string(tid)); + first = false; + } + out.append("]\n"); + return out; +} + +bool PowerHintSession::isActive() { + return mDescriptor->is_active.load(); +} + +bool PowerHintSession::isTimeout() { + auto now = std::chrono::steady_clock::now(); + return now >= getStaleTime(); +} + +const std::vector &PowerHintSession::getTidList() const { + return mDescriptor->threadIds; +} + +void PowerHintSession::setStale() { + // Reset to default uclamp value. + PowerSessionManager::getInstance()->setUclampMin(this, 0); + // Deliver a task to check if all sessions are inactive. + updateUniveralBoostMode(); + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); + } +} + +void PowerHintSession::wakeup() { + std::lock_guard guard(mSessionLock); + + // We only wake up non-paused and stale sessions + if (mSessionClosed || !isActive() || !isTimeout()) + return; + if (ATRACE_ENABLED()) { + std::string tag = StringPrintf("wakeup.%s(a:%d,s:%d)", getIdString().c_str(), isActive(), + isTimeout()); + ATRACE_NAME(tag.c_str()); + } + std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); + int min = std::max(mDescriptor->current_min, static_cast(adpfConfig->mUclampMinInit)); + mDescriptor->current_min = min; + PowerSessionManager::getInstance()->setUclampMinLocked(this, min); + mStaleTimerHandler->updateTimer(); + + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); + ATRACE_INT(sz.c_str(), min); + } +} + +void PowerHintSession::updateWorkPeriod(const std::vector &actualDurations) { + if (actualDurations.size() == 0) + return; + if (actualDurations.size() >= 2) { + const WorkDuration &last = actualDurations[actualDurations.size() - 2]; + mLastStartedTimeNs = last.timeStampNanos - last.durationNanos; + } + const WorkDuration ¤t = actualDurations.back(); + int64_t curr_start = current.timeStampNanos - current.durationNanos; + int64_t period = curr_start - mLastStartedTimeNs; + if (period > 0 && period < mDescriptor->duration.count() * 2) { + // Accounting workload period with moving average for the last 10 workload. + mWorkPeriodNs = 0.9 * mWorkPeriodNs + 0.1 * period; + if (ATRACE_ENABLED()) { + const std::string idstr = getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.period", idstr.c_str()); + ATRACE_INT(sz.c_str(), mWorkPeriodNs); + } + } + mLastStartedTimeNs = curr_start; + mLastDurationNs = current.durationNanos; +} + +time_point PowerHintSession::getEarlyBoostTime() { + std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); + int64_t earlyBoostTimeoutNs = + (int64_t)mDescriptor->duration.count() * adpfConfig->mEarlyBoostTimeFactor; + time_point nextStartTime = + mLastUpdatedTime.load() + nanoseconds(mWorkPeriodNs - mLastDurationNs); + return nextStartTime + nanoseconds(earlyBoostTimeoutNs); +} + +time_point PowerHintSession::getStaleTime() { + return mLastUpdatedTime.load() + + nanoseconds(static_cast( + mDescriptor->duration.count() * + HintManager::GetInstance()->GetAdpfProfile()->mStaleTimeFactor)); +} + +void PowerHintSession::StaleTimerHandler::updateTimer() { + time_point staleTime = + std::chrono::steady_clock::now() + + nanoseconds(static_cast( + mSession->mDescriptor->duration.count() * + HintManager::GetInstance()->GetAdpfProfile()->mStaleTimeFactor)); + updateTimer(staleTime); +} + +void PowerHintSession::StaleTimerHandler::updateTimer(time_point staleTime) { + mStaleTime.store(staleTime); + { + std::lock_guard guard(mMessageLock); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); + PowerHintMonitor::getInstance()->getLooper()->sendMessage(mSession->mStaleTimerHandler, + NULL); + } + mIsMonitoring.store(true); + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.stale", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); + } +} + +void PowerHintSession::StaleTimerHandler::handleMessage(const Message &) { + if (mIsSessionDead) { + return; + } + auto now = std::chrono::steady_clock::now(); + int64_t next = + static_cast(duration_cast(mStaleTime.load() - now).count()); + if (next > 0) { + // Schedule for the stale timeout check. + std::lock_guard guard(mMessageLock); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); + PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed( + next, mSession->mStaleTimerHandler, NULL); + } else { + mSession->setStale(); + mIsMonitoring.store(false); + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); + ATRACE_INT(sz.c_str(), 0); + } + } + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.stale", idstr.c_str()); + ATRACE_INT(sz.c_str(), mIsMonitoring ? 0 : 1); + } +} + +void PowerHintSession::StaleTimerHandler::setSessionDead() { + std::lock_guard guard(mStaleLock); + mIsSessionDead = true; + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); +} + +void PowerHintSession::EarlyBoostHandler::updateTimer(time_point boostTime) { + mBoostTime.store(boostTime); + { + std::lock_guard guard(mMessageLock); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); + PowerHintMonitor::getInstance()->getLooper()->sendMessage(mSession->mEarlyBoostHandler, + NULL); + } + mIsMonitoring.store(true); + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); + ATRACE_INT(sz.c_str(), 1); + } +} + +void PowerHintSession::EarlyBoostHandler::handleMessage(const Message &) { + std::lock_guard guard(mBoostLock); + if (mIsSessionDead) { + return; + } + auto now = std::chrono::steady_clock::now(); + int64_t next = + static_cast(duration_cast(mBoostTime.load() - now).count()); + if (next > 0) { + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); + ATRACE_INT(sz.c_str(), 1); + } + std::lock_guard guard(mMessageLock); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); + PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed( + next, mSession->mEarlyBoostHandler, NULL); + } else { + std::shared_ptr adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); + PowerSessionManager::getInstance()->setUclampMin(mSession, adpfConfig->mUclampMinHigh); + mIsMonitoring.store(false); + if (ATRACE_ENABLED()) { + const std::string idstr = mSession->getIdString(); + std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); + ATRACE_INT(sz.c_str(), adpfConfig->mUclampMinHigh); + sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); + ATRACE_INT(sz.c_str(), 2); + } + } +} + +void PowerHintSession::EarlyBoostHandler::setSessionDead() { + std::lock_guard guard(mBoostLock); + mIsSessionDead = true; + PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/PowerHintSession.h b/power-libperfmgr/aidl/PowerHintSession.h new file mode 100644 index 00000000..96b445ed --- /dev/null +++ b/power-libperfmgr/aidl/PowerHintSession.h @@ -0,0 +1,155 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include +#include + +#include +#include + +#include "adaptivecpu/AdaptiveCpu.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using aidl::android::hardware::power::BnPowerHintSession; +using aidl::android::hardware::power::WorkDuration; +using ::android::Message; +using ::android::MessageHandler; +using ::android::sp; +using std::chrono::milliseconds; +using std::chrono::nanoseconds; +using std::chrono::steady_clock; +using std::chrono::time_point; + +struct AppHintDesc { + AppHintDesc(int32_t tgid, int32_t uid, std::vector threadIds) + : tgid(tgid), + uid(uid), + threadIds(std::move(threadIds)), + duration(0LL), + current_min(0), + is_active(true), + update_count(0), + integral_error(0), + previous_error(0) {} + std::string toString() const; + const int32_t tgid; + const int32_t uid; + const std::vector threadIds; + nanoseconds duration; + int current_min; + // status + std::atomic is_active; + // pid + uint64_t update_count; + int64_t integral_error; + int64_t previous_error; +}; + +class PowerHintSession : public BnPowerHintSession { + public: + explicit PowerHintSession(std::shared_ptr adaptiveCpu, int32_t tgid, int32_t uid, + const std::vector &threadIds, int64_t durationNanos); + ~PowerHintSession(); + ndk::ScopedAStatus close() override; + ndk::ScopedAStatus pause() override; + ndk::ScopedAStatus resume() override; + ndk::ScopedAStatus updateTargetWorkDuration(int64_t targetDurationNanos) override; + ndk::ScopedAStatus reportActualWorkDuration( + const std::vector &actualDurations) override; + bool isActive(); + bool isTimeout(); + void wakeup(); + void setStale(); + // Is this hint session for a user application + bool isAppSession(); + const std::vector &getTidList() const; + int getUclampMin(); + void dumpToStream(std::ostream &stream); + + void updateWorkPeriod(const std::vector &actualDurations); + time_point getEarlyBoostTime(); + time_point getStaleTime(); + + private: + class StaleTimerHandler : public MessageHandler { + public: + StaleTimerHandler(PowerHintSession *session) + : mSession(session), mIsMonitoring(false), mIsSessionDead(false) {} + void updateTimer(); + void updateTimer(time_point staleTime); + void handleMessage(const Message &message) override; + void setSessionDead(); + + private: + PowerHintSession *mSession; + std::mutex mStaleLock; + std::mutex mMessageLock; + std::atomic> mStaleTime; + std::atomic mIsMonitoring; + bool mIsSessionDead; + }; + + class EarlyBoostHandler : public MessageHandler { + public: + EarlyBoostHandler(PowerHintSession *session) + : mSession(session), mIsMonitoring(false), mIsSessionDead(false) {} + void updateTimer(time_point boostTime); + void handleMessage(const Message &message) override; + void setSessionDead(); + + private: + PowerHintSession *mSession; + std::mutex mBoostLock; + std::mutex mMessageLock; + std::atomic> mBoostTime; + std::atomic mIsMonitoring; + bool mIsSessionDead; + }; + + private: + void updateUniveralBoostMode(); + int setSessionUclampMin(int32_t min); + std::string getIdString() const; + const std::shared_ptr mAdaptiveCpu; + AppHintDesc *mDescriptor = nullptr; + sp mStaleTimerHandler; + sp mEarlyBoostHandler; + std::atomic> mLastUpdatedTime; + sp mPowerManagerHandler; + std::mutex mSessionLock; + std::atomic mSessionClosed = false; + // These 3 variables are for earlyboost work period estimation. + int64_t mLastStartedTimeNs; + int64_t mLastDurationNs; + int64_t mWorkPeriodNs; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/PowerSessionManager.cpp b/power-libperfmgr/aidl/PowerSessionManager.cpp new file mode 100644 index 00000000..516942ac --- /dev/null +++ b/power-libperfmgr/aidl/PowerSessionManager.cpp @@ -0,0 +1,267 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-libperfmgr" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "PowerSessionManager.h" + +#include +#include +#include +#include +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using ::android::perfmgr::HintManager; + +namespace { +/* there is no glibc or bionic wrapper */ +struct sched_attr { + __u32 size; + __u32 sched_policy; + __u64 sched_flags; + __s32 sched_nice; + __u32 sched_priority; + __u64 sched_runtime; + __u64 sched_deadline; + __u64 sched_period; + __u32 sched_util_min; + __u32 sched_util_max; +}; + +static int sched_setattr(int pid, struct sched_attr *attr, unsigned int flags) { + if (!HintManager::GetInstance()->GetAdpfProfile()->mUclampMinOn) { + ALOGV("PowerSessionManager:%s: skip", __func__); + return 0; + } + return syscall(__NR_sched_setattr, pid, attr, flags); +} + +static void set_uclamp_min(int tid, int min) { + static constexpr int32_t kMaxUclampValue = 1024; + min = std::max(0, min); + min = std::min(min, kMaxUclampValue); + + sched_attr attr = {}; + attr.size = sizeof(attr); + + attr.sched_flags = (SCHED_FLAG_KEEP_ALL | SCHED_FLAG_UTIL_CLAMP_MIN); + attr.sched_util_min = min; + + int ret = sched_setattr(tid, &attr, 0); + if (ret) { + ALOGW("sched_setattr failed for thread %d, err=%d", tid, errno); + } +} +} // namespace + +void PowerSessionManager::updateHintMode(const std::string &mode, bool enabled) { + ALOGV("PowerSessionManager::updateHintMode: mode: %s, enabled: %d", mode.c_str(), enabled); + if (enabled && mode.compare(0, 8, "REFRESH_") == 0) { + if (mode.compare("REFRESH_120FPS") == 0) { + mDisplayRefreshRate = 120; + } else if (mode.compare("REFRESH_90FPS") == 0) { + mDisplayRefreshRate = 90; + } else if (mode.compare("REFRESH_60FPS") == 0) { + mDisplayRefreshRate = 60; + } + } + if (HintManager::GetInstance()->GetAdpfProfile()) { + HintManager::GetInstance()->SetAdpfProfile(mode); + } +} + +void PowerSessionManager::updateHintBoost(const std::string &boost, int32_t durationMs) { + ATRACE_CALL(); + ALOGV("PowerSessionManager::updateHintBoost: boost: %s, durationMs: %d", boost.c_str(), + durationMs); + if (boost.compare("DISPLAY_UPDATE_IMMINENT") == 0) { + PowerHintMonitor::getInstance()->getLooper()->sendMessage(mWakeupHandler, NULL); + } +} + +void PowerSessionManager::wakeSessions() { + std::lock_guard guard(mLock); + for (PowerHintSession *s : mSessions) { + s->wakeup(); + } +} + +int PowerSessionManager::getDisplayRefreshRate() { + return mDisplayRefreshRate; +} + +void PowerSessionManager::addPowerSession(PowerHintSession *session) { + std::lock_guard guard(mLock); + for (auto t : session->getTidList()) { + mTidSessionListMap[t].insert(session); + if (mTidRefCountMap.find(t) == mTidRefCountMap.end()) { + if (!SetTaskProfiles(t, {"ResetUclampGrp"})) { + ALOGW("Failed to set ResetUclampGrp task profile for tid:%d", t); + } else { + mTidRefCountMap[t] = 1; + } + continue; + } + if (mTidRefCountMap[t] <= 0) { + ALOGE("Error! Unexpected zero/negative RefCount:%d for tid:%d", mTidRefCountMap[t], t); + continue; + } + mTidRefCountMap[t]++; + } + mSessions.insert(session); +} + +void PowerSessionManager::removePowerSession(PowerHintSession *session) { + std::lock_guard guard(mLock); + for (auto t : session->getTidList()) { + if (mTidRefCountMap.find(t) == mTidRefCountMap.end()) { + ALOGE("Unexpected Error! Failed to look up tid:%d in TidRefCountMap", t); + continue; + } + mTidSessionListMap[t].erase(session); + mTidRefCountMap[t]--; + if (mTidRefCountMap[t] <= 0) { + if (!SetTaskProfiles(t, {"NoResetUclampGrp"})) { + ALOGW("Failed to set NoResetUclampGrp task profile for tid:%d", t); + } + mTidRefCountMap.erase(t); + } + } + mSessions.erase(session); +} + +void PowerSessionManager::setUclampMin(PowerHintSession *session, int val) { + std::lock_guard guard(mLock); + setUclampMinLocked(session, val); +} + +void PowerSessionManager::setUclampMinLocked(PowerHintSession *session, int val) { + for (auto t : session->getTidList()) { + // Get thex max uclamp.min across sessions which include the tid. + int tidMax = 0; + for (PowerHintSession *s : mTidSessionListMap[t]) { + if (!s->isActive() || s->isTimeout()) + continue; + tidMax = std::max(tidMax, s->getUclampMin()); + } + set_uclamp_min(t, std::max(val, tidMax)); + } +} + +std::optional PowerSessionManager::isAnyAppSessionActive() { + std::lock_guard guard(mLock); + bool active = false; + for (PowerHintSession *s : mSessions) { + // session active and not stale is actually active. + if (s->isActive() && !s->isTimeout() && s->isAppSession()) { + active = true; + break; + } + } + if (active == mActive) { + return std::nullopt; + } else { + mActive = active; + } + + return active; +} + +void PowerSessionManager::handleMessage(const Message &) { + auto active = isAnyAppSessionActive(); + if (!active.has_value()) { + return; + } + if (active.value()) { + disableSystemTopAppBoost(); + } else { + enableSystemTopAppBoost(); + } +} + +void PowerSessionManager::WakeupHandler::handleMessage(const Message &) { + PowerSessionManager::getInstance()->wakeSessions(); +} + +void PowerSessionManager::dumpToFd(int fd) { + std::ostringstream dump_buf; + std::lock_guard guard(mLock); + dump_buf << "========== Begin PowerSessionManager ADPF list ==========\n"; + for (PowerHintSession *s : mSessions) { + s->dumpToStream(dump_buf); + dump_buf << " Tid:Ref["; + for (size_t i = 0, len = s->getTidList().size(); i < len; i++) { + int t = s->getTidList()[i]; + dump_buf << t << ":" << mTidSessionListMap[t].size(); + if (i < len - 1) { + dump_buf << ", "; + } + } + dump_buf << "]\n"; + } + dump_buf << "========== End PowerSessionManager ADPF list ==========\n"; + if (!::android::base::WriteStringToFd(dump_buf.str(), fd)) { + ALOGE("Failed to dump one of session list to fd:%d", fd); + } +} + +void PowerSessionManager::enableSystemTopAppBoost() { + if (HintManager::GetInstance()->IsHintSupported(kDisableBoostHintName)) { + ALOGV("PowerSessionManager::enableSystemTopAppBoost!!"); + HintManager::GetInstance()->EndHint(kDisableBoostHintName); + } +} + +void PowerSessionManager::disableSystemTopAppBoost() { + if (HintManager::GetInstance()->IsHintSupported(kDisableBoostHintName)) { + ALOGV("PowerSessionManager::disableSystemTopAppBoost!!"); + HintManager::GetInstance()->DoHint(kDisableBoostHintName); + } +} + +// =========== PowerHintMonitor implementation start from here =========== +void PowerHintMonitor::start() { + if (!isRunning()) { + run("PowerHintMonitor", ::android::PRIORITY_HIGHEST); + } +} + +bool PowerHintMonitor::threadLoop() { + while (true) { + mLooper->pollOnce(-1); + } + return true; +} + +sp PowerHintMonitor::getLooper() { + return mLooper; +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/PowerSessionManager.h b/power-libperfmgr/aidl/PowerSessionManager.h new file mode 100644 index 00000000..6cd0886c --- /dev/null +++ b/power-libperfmgr/aidl/PowerSessionManager.h @@ -0,0 +1,124 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include + +#include +#include +#include + +#include "PowerHintSession.h" + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +using ::android::Looper; +using ::android::Message; +using ::android::MessageHandler; +using ::android::Thread; +using ::android::perfmgr::HintManager; + +constexpr char kPowerHalAdpfDisableTopAppBoost[] = "vendor.powerhal.adpf.disable.hint"; + +class PowerSessionManager : public MessageHandler { + public: + // current hint info + void updateHintMode(const std::string &mode, bool enabled); + void updateHintBoost(const std::string &boost, int32_t durationMs); + int getDisplayRefreshRate(); + // monitoring session status + void addPowerSession(PowerHintSession *session); + void removePowerSession(PowerHintSession *session); + void setUclampMin(PowerHintSession *session, int min); + void setUclampMinLocked(PowerHintSession *session, int min); + void handleMessage(const Message &message) override; + void dumpToFd(int fd); + + // Singleton + static sp getInstance() { + static sp instance = new PowerSessionManager(); + return instance; + } + + private: + class WakeupHandler : public MessageHandler { + public: + WakeupHandler() {} + void handleMessage(const Message &message) override; + }; + + private: + void wakeSessions(); + std::optional isAnyAppSessionActive(); + void disableSystemTopAppBoost(); + void enableSystemTopAppBoost(); + const std::string kDisableBoostHintName; + + std::unordered_set mSessions; // protected by mLock + std::unordered_map mTidRefCountMap; // protected by mLock + std::unordered_map> mTidSessionListMap; + sp mWakeupHandler; + bool mActive; // protected by mLock + /** + * mLock to pretect the above data objects opertions. + **/ + std::mutex mLock; + int mDisplayRefreshRate; + // Singleton + PowerSessionManager() + : kDisableBoostHintName(::android::base::GetProperty(kPowerHalAdpfDisableTopAppBoost, + "ADPF_DISABLE_TA_BOOST")), + mActive(false), + mDisplayRefreshRate(60) { + mWakeupHandler = sp(new WakeupHandler()); + } + PowerSessionManager(PowerSessionManager const &) = delete; + void operator=(PowerSessionManager const &) = delete; +}; + +class PowerHintMonitor : public Thread { + public: + void start(); + bool threadLoop() override; + sp getLooper(); + // Singleton + static sp getInstance() { + static sp instance = new PowerHintMonitor(); + return instance; + } + PowerHintMonitor(PowerHintMonitor const &) = delete; + void operator=(PowerHintMonitor const &) = delete; + + private: + sp mLooper; + // Singleton + PowerHintMonitor() : Thread(false), mLooper(new Looper(true)) {} +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/aidl/android.hardware.power-service.xiaomi_sdm660-libperfmgr.rc b/power-libperfmgr/aidl/android.hardware.power-service.xiaomi_sdm660-libperfmgr.rc new file mode 100644 index 00000000..16ecf4f9 --- /dev/null +++ b/power-libperfmgr/aidl/android.hardware.power-service.xiaomi_sdm660-libperfmgr.rc @@ -0,0 +1,30 @@ +service vendor.power-hal-aidl /vendor/bin/hw/android.hardware.power-service.xiaomi_sdm660-libperfmgr + class hal + user root + group system + priority -20 + +on late-fs + start vendor.power-hal-aidl + +# Restart powerHAL when framework died +on property:init.svc.zygote=restarting && property:vendor.powerhal.state=* + setprop vendor.powerhal.state "" + setprop vendor.powerhal.rendering "" + restart vendor.power-hal-aidl + +# Restart powerHAL when debug property set +on property:ro.debuggable=1 && property:vendor.powerhal.config.debug=* + restart vendor.power-hal-aidl + +on property:persist.vendor.powerhal.config.debug=* + setprop vendor.powerhal.config.debug ${persist.vendor.powerhal.config.debug} + +# Clean up after b/163539793 resolved +on property:vendor.powerhal.dalvik.vm.dex2oat-threads=* + setprop dalvik.vm.dex2oat-threads ${vendor.powerhal.dalvik.vm.dex2oat-threads} + setprop dalvik.vm.restore-dex2oat-threads ${vendor.powerhal.dalvik.vm.dex2oat-threads} + +on property:vendor.powerhal.dalvik.vm.dex2oat-cpu-set=* + setprop dalvik.vm.dex2oat-cpu-set ${vendor.powerhal.dalvik.vm.dex2oat-cpu-set} + setprop dalvik.vm.restore-dex2oat-cpu-set ${vendor.powerhal.dalvik.vm.dex2oat-cpu-set} diff --git a/power-libperfmgr/aidl/android.hardware.power-service.xiaomi_sdm660.xml b/power-libperfmgr/aidl/android.hardware.power-service.xiaomi_sdm660.xml new file mode 100644 index 00000000..927ba22d --- /dev/null +++ b/power-libperfmgr/aidl/android.hardware.power-service.xiaomi_sdm660.xml @@ -0,0 +1,7 @@ + + + android.hardware.power + 3 + IPower/default + + diff --git a/power-libperfmgr/aidl/service.cpp b/power-libperfmgr/aidl/service.cpp new file mode 100644 index 00000000..a380fd1c --- /dev/null +++ b/power-libperfmgr/aidl/service.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-libperfmgr" + +#include +#include +#include +#include +#include +#include + +#include + +#include "Power.h" +#include "PowerExt.h" +#include "PowerSessionManager.h" +#include "adaptivecpu/AdaptiveCpu.h" + +using aidl::google::hardware::power::impl::pixel::AdaptiveCpu; +using aidl::google::hardware::power::impl::pixel::Power; +using aidl::google::hardware::power::impl::pixel::PowerExt; +using aidl::google::hardware::power::impl::pixel::PowerHintMonitor; +using aidl::google::hardware::power::impl::pixel::PowerSessionManager; +using ::android::perfmgr::HintManager; + +constexpr std::string_view kPowerHalInitProp("vendor.powerhal.init"); + +int main() { + // Parse config but do not start the looper + std::shared_ptr hm = HintManager::GetInstance(); + if (!hm) { + LOG(FATAL) << "HintManager Init failed"; + } + + // single thread + ABinderProcess_setThreadPoolMaxThreadCount(0); + + std::shared_ptr adaptiveCpu = std::make_shared(); + + // core service + std::shared_ptr pw = ndk::SharedRefBase::make(adaptiveCpu); + ndk::SpAIBinder pwBinder = pw->asBinder(); + AIBinder_setMinSchedulerPolicy(pwBinder.get(), SCHED_NORMAL, -20); + + // extension service + std::shared_ptr pwExt = ndk::SharedRefBase::make(adaptiveCpu); + auto pwExtBinder = pwExt->asBinder(); + AIBinder_setMinSchedulerPolicy(pwExtBinder.get(), SCHED_NORMAL, -20); + + // attach the extension to the same binder we will be registering + CHECK(STATUS_OK == AIBinder_setExtension(pwBinder.get(), pwExt->asBinder().get())); + + const std::string instance = std::string() + Power::descriptor + "/default"; + binder_status_t status = AServiceManager_addService(pw->asBinder().get(), instance.c_str()); + CHECK(status == STATUS_OK); + LOG(INFO) << "Pixel Power HAL AIDL Service with Extension is started."; + + if (HintManager::GetInstance()->GetAdpfProfile()) { + PowerHintMonitor::getInstance()->start(); + } + + std::thread initThread([&]() { + ::android::base::WaitForProperty(kPowerHalInitProp.data(), "1"); + HintManager::GetInstance()->Start(); + }); + initThread.detach(); + + ABinderProcess_joinThreadPool(); + + // should not reach + LOG(ERROR) << "Pixel Power HAL AIDL Service with Extension just died."; + return EXIT_FAILURE; +} diff --git a/power-libperfmgr/disp-power/InteractionHandler.cpp b/power-libperfmgr/disp-power/InteractionHandler.cpp new file mode 100644 index 00000000..d2357a6a --- /dev/null +++ b/power-libperfmgr/disp-power/InteractionHandler.cpp @@ -0,0 +1,283 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "powerhal-libperfmgr" +#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) + +#include "InteractionHandler.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define MAX_LENGTH 64 + +#define MSINSEC 1000L +#define NSINMS 1000000L + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +namespace { + +static const bool kDisplayIdleSupport = + ::android::base::GetBoolProperty("vendor.powerhal.disp.idle_support", true); +static const std::array kDispIdlePath = {"/sys/class/drm/card0/device/idle_state", + "/sys/class/graphics/fb0/idle_state"}; +static const uint32_t kWaitMs = + ::android::base::GetUintProperty("vendor.powerhal.disp.idle_wait", /*default*/ 100U); +static const uint32_t kMinDurationMs = + ::android::base::GetUintProperty("vendor.powerhal.interaction.min", /*default*/ 1400U); +static const uint32_t kMaxDurationMs = + ::android::base::GetUintProperty("vendor.powerhal.interaction.max", /*default*/ 5650U); +static const uint32_t kDurationOffsetMs = + ::android::base::GetUintProperty("vendor.powerhal.interaction.offset", /*default*/ 650U); + +static size_t CalcTimespecDiffMs(struct timespec start, struct timespec end) { + size_t diff_in_ms = 0; + diff_in_ms += (end.tv_sec - start.tv_sec) * MSINSEC; + diff_in_ms += (end.tv_nsec - start.tv_nsec) / NSINMS; + return diff_in_ms; +} + +static int FbIdleOpen(void) { + int fd; + for (const auto &path : kDispIdlePath) { + fd = open(path, O_RDONLY); + if (fd >= 0) + return fd; + } + ALOGE("Unable to open fb idle state path (%d)", errno); + return -1; +} + +} // namespace + +using ::android::perfmgr::HintManager; + +InteractionHandler::InteractionHandler() + : mState(INTERACTION_STATE_UNINITIALIZED), mDurationMs(0) {} + +InteractionHandler::~InteractionHandler() { + Exit(); +} + +bool InteractionHandler::Init() { + std::lock_guard lk(mLock); + + if (mState != INTERACTION_STATE_UNINITIALIZED) + return true; + + int fd = FbIdleOpen(); + if (fd < 0) + return false; + mIdleFd = fd; + + mEventFd = eventfd(0, EFD_NONBLOCK); + if (mEventFd < 0) { + ALOGE("Unable to create event fd (%d)", errno); + close(mIdleFd); + return false; + } + + mState = INTERACTION_STATE_IDLE; + mThread = std::unique_ptr(new std::thread(&InteractionHandler::Routine, this)); + + return true; +} + +void InteractionHandler::Exit() { + std::unique_lock lk(mLock); + if (mState == INTERACTION_STATE_UNINITIALIZED) + return; + + AbortWaitLocked(); + mState = INTERACTION_STATE_UNINITIALIZED; + lk.unlock(); + + mCond.notify_all(); + mThread->join(); + + close(mEventFd); + close(mIdleFd); +} + +void InteractionHandler::PerfLock() { + ALOGV("%s: acquiring perf lock", __func__); + if (!HintManager::GetInstance()->DoHint("INTERACTION")) { + ALOGE("%s: do hint INTERACTION failed", __func__); + } +} + +void InteractionHandler::PerfRel() { + ALOGV("%s: releasing perf lock", __func__); + if (!HintManager::GetInstance()->EndHint("INTERACTION")) { + ALOGE("%s: end hint INTERACTION failed", __func__); + } +} + +void InteractionHandler::Acquire(int32_t duration) { + ATRACE_CALL(); + + std::lock_guard lk(mLock); + + int inputDuration = duration + kDurationOffsetMs; + int finalDuration; + if (inputDuration > kMaxDurationMs) + finalDuration = kMaxDurationMs; + else if (inputDuration > kMinDurationMs) + finalDuration = inputDuration; + else + finalDuration = kMinDurationMs; + + // Fallback to do boost directly + // 1) override property is set OR + // 2) InteractionHandler not initialized + if (!kDisplayIdleSupport || mState == INTERACTION_STATE_UNINITIALIZED) { + HintManager::GetInstance()->DoHint("INTERACTION", std::chrono::milliseconds(finalDuration)); + return; + } + + struct timespec cur_timespec; + clock_gettime(CLOCK_MONOTONIC, &cur_timespec); + if (mState != INTERACTION_STATE_IDLE && finalDuration <= mDurationMs) { + size_t elapsed_time = CalcTimespecDiffMs(mLastTimespec, cur_timespec); + // don't hint if previous hint's duration covers this hint's duration + if (elapsed_time <= (mDurationMs - finalDuration)) { + ALOGV("%s: Previous duration (%d) cover this (%d) elapsed: %lld", __func__, + static_cast(mDurationMs), static_cast(finalDuration), + static_cast(elapsed_time)); + return; + } + } + mLastTimespec = cur_timespec; + mDurationMs = finalDuration; + + ALOGV("%s: input: %d final duration: %d", __func__, duration, finalDuration); + + if (mState == INTERACTION_STATE_WAITING) + AbortWaitLocked(); + else if (mState == INTERACTION_STATE_IDLE) + PerfLock(); + + mState = INTERACTION_STATE_INTERACTION; + mCond.notify_one(); +} + +void InteractionHandler::Release() { + std::lock_guard lk(mLock); + if (mState == INTERACTION_STATE_WAITING) { + ATRACE_CALL(); + PerfRel(); + mState = INTERACTION_STATE_IDLE; + } else { + // clear any wait aborts pending in event fd + uint64_t val; + ssize_t ret = read(mEventFd, &val, sizeof(val)); + + ALOGW_IF(ret < 0, "%s: failed to clear eventfd (%zd, %d)", __func__, ret, errno); + } +} + +// should be called while locked +void InteractionHandler::AbortWaitLocked() { + uint64_t val = 1; + ssize_t ret = write(mEventFd, &val, sizeof(val)); + if (ret != sizeof(val)) + ALOGW("Unable to write to event fd (%zd)", ret); +} + +void InteractionHandler::WaitForIdle(int32_t wait_ms, int32_t timeout_ms) { + char data[MAX_LENGTH]; + ssize_t ret; + struct pollfd pfd[2]; + + ATRACE_CALL(); + + ALOGV("%s: wait:%d timeout:%d", __func__, wait_ms, timeout_ms); + + pfd[0].fd = mEventFd; + pfd[0].events = POLLIN; + pfd[1].fd = mIdleFd; + pfd[1].events = POLLPRI | POLLERR; + + ret = poll(pfd, 1, wait_ms); + if (ret > 0) { + ALOGV("%s: wait aborted", __func__); + return; + } else if (ret < 0) { + ALOGE("%s: error in poll while waiting", __func__); + return; + } + + ret = pread(mIdleFd, data, sizeof(data), 0); + if (!ret) { + ALOGE("%s: Unexpected EOF!", __func__); + return; + } + + if (!strncmp(data, "idle", 4)) { + ALOGV("%s: already idle", __func__); + return; + } + + ret = poll(pfd, 2, timeout_ms); + if (ret < 0) + ALOGE("%s: Error on waiting for idle (%zd)", __func__, ret); + else if (ret == 0) + ALOGV("%s: timed out waiting for idle", __func__); + else if (pfd[0].revents) + ALOGV("%s: wait for idle aborted", __func__); + else if (pfd[1].revents) + ALOGV("%s: idle detected", __func__); +} + +void InteractionHandler::Routine() { + pthread_setname_np(pthread_self(), "DispIdle"); + std::unique_lock lk(mLock, std::defer_lock); + + while (true) { + lk.lock(); + mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; }); + if (mState == INTERACTION_STATE_UNINITIALIZED) + return; + mState = INTERACTION_STATE_WAITING; + lk.unlock(); + + WaitForIdle(kWaitMs, mDurationMs); + Release(); + } +} + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/power-libperfmgr/disp-power/InteractionHandler.h b/power-libperfmgr/disp-power/InteractionHandler.h new file mode 100644 index 00000000..c88f7d47 --- /dev/null +++ b/power-libperfmgr/disp-power/InteractionHandler.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include +#include +#include + +namespace aidl { +namespace google { +namespace hardware { +namespace power { +namespace impl { +namespace pixel { + +enum InteractionState { + INTERACTION_STATE_UNINITIALIZED, + INTERACTION_STATE_IDLE, + INTERACTION_STATE_INTERACTION, + INTERACTION_STATE_WAITING, +}; + +class InteractionHandler { + public: + InteractionHandler(); + ~InteractionHandler(); + bool Init(); + void Exit(); + void Acquire(int32_t duration); + + private: + void Release(); + void WaitForIdle(int32_t wait_ms, int32_t timeout_ms); + void AbortWaitLocked(); + void Routine(); + + void PerfLock(); + void PerfRel(); + + enum InteractionState mState; + int mIdleFd; + int mEventFd; + int32_t mDurationMs; + struct timespec mLastTimespec; + std::unique_ptr mThread; + std::mutex mLock; + std::condition_variable mCond; +}; + +} // namespace pixel +} // namespace impl +} // namespace power +} // namespace hardware +} // namespace google +} // namespace aidl diff --git a/configs/powerhint/powerhint.json b/power-libperfmgr/sdm636_powerhint.json similarity index 60% rename from configs/powerhint/powerhint.json rename to power-libperfmgr/sdm636_powerhint.json index 9a899846..c04e4329 100644 --- a/configs/powerhint/powerhint.json +++ b/power-libperfmgr/sdm636_powerhint.json @@ -43,8 +43,8 @@ "Name": "GPUMaxFreq", "Path": "/sys/class/kgsl/kgsl-3d0/devfreq/max_freq", "Values": [ - "647000000", - "465000000" + "430000000", + "370000000" ], "DefaultIndex": 0, "ResetOnInit": true @@ -53,12 +53,23 @@ "Name": "GPUMinFreq", "Path": "/sys/class/kgsl/kgsl-3d0/devfreq/min_freq", "Values": [ - "647000000", - "465000000", + "430000000", + "370000000", "266000000" ], "ResetOnInit": true }, + { + "Name": "GPUBusMinFreq", + "Path": "/sys/class/devfreq/soc:qcom,gpubw/min_freq", + "Values": [ + "6881", + "5931", + "3879", + "0" + ], + "ResetOnInit": true + }, { "Name": "GPUForceRailOn", "Path": "/sys/class/kgsl/kgsl-3d0/force_rail_on", @@ -90,6 +101,7 @@ "Name": "TASchedtuneBoost", "Path": "/dev/stune/top-app/schedtune.boost", "Values": [ + "10", "5", "1" ], @@ -113,6 +125,52 @@ ], "ResetOnInit": true }, + { + "Name": "CPUBWHystLength", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/bw_hwmon/hyst_length", + "Values": [ + "0", + "10" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWSampleMs", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/bw_hwmon/sample_ms", + "Values": [ + "10", + "4" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWIOPercent", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/bw_hwmon/io_percent", + "Values": [ + "85", + "50" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWMinFreq", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/min_freq", + "Values": [ + "6881", + "3879", + "381" + ], + "ResetOnInit": true + }, + { + "Name": "EnergyAware", + "Path": "/proc/sys/kernel/sched_energy_aware", + "Values": [ + "0", + "1" + ], + "ResetOnInit": true + }, { "Name": "PowerHALMainState", "Path": "vendor.powerhal.state", @@ -159,15 +217,21 @@ }, { "PowerHint": "INTERACTION", - "Node": "CPULittleClusterMinFreq", + "Node": "CPUBigClusterMinFreq", "Duration": 0, "Value": "1113600" }, + { + "PowerHint": "INTERACTION", + "Node": "CPULittleClusterMinFreq", + "Duration": 0, + "Value": "633600" + }, { "PowerHint": "INTERACTION", "Node": "TASchedtuneBoost", "Duration": 0, - "Value": "5" + "Value": "10" }, { "PowerHint": "INTERACTION", @@ -175,58 +239,88 @@ "Duration": 0, "Value": "0" }, + { + "PowerHint": "INTERACTION", + "Node": "CPUBWHystLength", + "Duration": 0, + "Value": "0" + }, { "PowerHint": "INTERACTION", "Node": "CPUBWHistMemory", "Duration": 0, "Value": "0" }, + { + "PowerHint": "INTERACTION", + "Node": "CPUBWMinFreq", + "Duration": 0, + "Value": "3879" + }, + { + "PowerHint": "LAUNCH", + "Node": "EnergyAware", + "Duration": 3000, + "Value": "0" + }, { "PowerHint": "LAUNCH", "Node": "CPUBigClusterMaxFreq", - "Duration": 5000, + "Duration": 3000, "Value": "9999999" }, { "PowerHint": "LAUNCH", "Node": "CPUBigClusterMinFreq", - "Duration": 5000, + "Duration": 3000, "Value": "9999999" }, { "PowerHint": "LAUNCH", "Node": "CPULittleClusterMinFreq", - "Duration": 5000, + "Duration": 3000, "Value": "9999999" }, { "PowerHint": "LAUNCH", "Node": "CPUBWHystTriggerCount", - "Duration": 5000, + "Duration": 3000, + "Value": "0" + }, + { + "PowerHint": "LAUNCH", + "Node": "CPUBWHystLength", + "Duration": 3000, "Value": "0" }, { "PowerHint": "LAUNCH", "Node": "CPUBWHistMemory", - "Duration": 5000, + "Duration": 3000, "Value": "0" }, + { + "PowerHint": "LAUNCH", + "Node": "CPUBWMinFreq", + "Duration": 3000, + "Value": "6881" + }, { "PowerHint": "LAUNCH", "Node": "GPUForceClkOn", - "Duration": 5000, + "Duration": 3000, "Value": "1" }, { "PowerHint": "LAUNCH", "Node": "GPUForceRailOn", - "Duration": 5000, + "Duration": 3000, "Value": "1" }, { "PowerHint": "LAUNCH", "Node": "GPUIdleTimer", - "Duration": 5000, + "Duration": 3000, "Value": "10000" }, { @@ -239,13 +333,61 @@ "PowerHint": "EXPENSIVE_RENDERING", "Node": "GPUMinFreq", "Duration": 0, - "Value": "465000000" + "Value": "647000000" }, { "PowerHint": "EXPENSIVE_RENDERING", "Node": "GPUMaxFreq", "Duration": 0, "Value": "647000000" + }, + { + "PowerHint": "Flipendo", + "Node": "CPULittleClusterMaxFreq", + "Duration": 0, + "Value": "1113600" + }, + { + "PowerHint": "Flipendo", + "Node": "CPUBigClusterMaxFreq", + "Duration": 0, + "Value": "1401600" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "CPUBigClusterMaxFreq", + "Duration": 0, + "Value": "9999999" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "CPUBigClusterMinFreq", + "Duration": 0, + "Value": "9999999" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "CPULittleClusterMaxFreq", + "Duration": 0, + "Value": "9999999" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "CPULittleClusterMinFreq", + "Duration": 0, + "Value": "9999999" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "GPUMaxFreq", + "Duration": 0, + "Value": "430000000" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "GPUMinFreq", + "Duration": 0, + "Value": "430000000" } ] } diff --git a/power-libperfmgr/sdm660_powerhint.json b/power-libperfmgr/sdm660_powerhint.json new file mode 100644 index 00000000..5d2c0e74 --- /dev/null +++ b/power-libperfmgr/sdm660_powerhint.json @@ -0,0 +1,414 @@ +{ + "Nodes": [ + { + "Name": "CPULittleClusterMaxFreq", + "Path": "/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq", + "Values": [ + "9999999", + "1113600" + ], + "DefaultIndex": 0, + "ResetOnInit": true + }, + { + "Name": "CPULittleClusterMinFreq", + "Path": "/sys/devices/system/cpu/cpu0/cpufreq/scaling_min_freq", + "Values": [ + "9999999", + "1113600", + "633600" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBigClusterMaxFreq", + "Path": "/sys/devices/system/cpu/cpu4/cpufreq/scaling_max_freq", + "Values": [ + "9999999", + "1401600" + ], + "DefaultIndex": 0, + "ResetOnInit": true + }, + { + "Name": "CPUBigClusterMinFreq", + "Path": "/sys/devices/system/cpu/cpu4/cpufreq/scaling_min_freq", + "Values": [ + "9999999", + "1113600" + ], + "ResetOnInit": true + }, + { + "Name": "GPUMaxFreq", + "Path": "/sys/class/kgsl/kgsl-3d0/devfreq/max_freq", + "Values": [ + "647000000", + "588000000", + "465000000", + "370000000", + "266000000" + ], + "DefaultIndex": 0, + "ResetOnInit": true + }, + { + "Name": "GPUMinFreq", + "Path": "/sys/class/kgsl/kgsl-3d0/devfreq/min_freq", + "Values": [ + "647000000", + "588000000", + "465000000", + "370000000", + "266000000", + "160000000" + ], + "ResetOnInit": true + }, + { + "Name": "GPUBusMinFreq", + "Path": "/sys/class/devfreq/soc:qcom,gpubw/min_freq", + "Values": [ + "6881", + "5931", + "3879", + "0" + ], + "ResetOnInit": true + }, + { + "Name": "GPUForceRailOn", + "Path": "/sys/class/kgsl/kgsl-3d0/force_rail_on", + "Values": [ + "1", + "0" + ], + "ResetOnInit": true + }, + { + "Name": "GPUForceClkOn", + "Path": "/sys/class/kgsl/kgsl-3d0/force_clk_on", + "Values": [ + "1", + "0" + ], + "ResetOnInit": true + }, + { + "Name": "GPUIdleTimer", + "Path": "/sys/class/kgsl/kgsl-3d0/idle_timer", + "Values": [ + "10000", + "64" + ], + "ResetOnInit": true + }, + { + "Name": "TASchedtuneBoost", + "Path": "/dev/stune/top-app/schedtune.boost", + "Values": [ + "10", + "5", + "1" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWHystTriggerCount", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/bw_hwmon/hyst_trigger_count", + "Values": [ + "0", + "3" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWHistMemory", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/bw_hwmon/hist_memory", + "Values": [ + "0", + "20" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWHystLength", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/bw_hwmon/hyst_length", + "Values": [ + "0", + "10" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWSampleMs", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/bw_hwmon/sample_ms", + "Values": [ + "10", + "4" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWIOPercent", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/bw_hwmon/io_percent", + "Values": [ + "85", + "50" + ], + "ResetOnInit": true + }, + { + "Name": "CPUBWMinFreq", + "Path": "/sys/class/devfreq/soc:qcom,cpu-cpu-ddr-bw/min_freq", + "Values": [ + "6881", + "3879", + "381" + ], + "ResetOnInit": true + }, + { + "Name": "EnergyAware", + "Path": "/proc/sys/kernel/sched_energy_aware", + "Values": [ + "0", + "1" + ], + "ResetOnInit": true + }, + { + "Name": "KernelBatterySaver", + "Path": "/sys/module/battery_saver/parameters/enabled", + "Values": [ + "Y", + "N" + ], + "ResetOnInit": true + }, + { + "Name": "PowerHALMainState", + "Path": "vendor.powerhal.state", + "Values": [ + "SUSTAINED_PERFORMANCE", + "" + ], + "Type": "Property" + }, + { + "Name": "PowerHALRenderingState", + "Path": "vendor.powerhal.rendering", + "Values": [ + "EXPENSIVE_RENDERING", + "" + ], + "Type": "Property" + } + ], + "Actions": [ + { + "PowerHint": "SUSTAINED_PERFORMANCE", + "Node": "PowerHALMainState", + "Duration": 0, + "Value": "SUSTAINED_PERFORMANCE" + }, + { + "PowerHint": "SUSTAINED_PERFORMANCE", + "Node": "CPUBigClusterMaxFreq", + "Duration": 0, + "Value": "1401600" + }, + { + "PowerHint": "SUSTAINED_PERFORMANCE", + "Node": "CPULittleClusterMaxFreq", + "Duration": 0, + "Value": "1113600" + }, + { + "PowerHint": "SUSTAINED_PERFORMANCE", + "Node": "GPUMaxFreq", + "Duration": 0, + "Value": "465000000" + }, + { + "PowerHint": "INTERACTION", + "Node": "CPUBigClusterMinFreq", + "Duration": 0, + "Value": "1113600" + }, + { + "PowerHint": "INTERACTION", + "Node": "CPULittleClusterMinFreq", + "Duration": 0, + "Value": "633600" + }, + { + "PowerHint": "INTERACTION", + "Node": "TASchedtuneBoost", + "Duration": 0, + "Value": "10" + }, + { + "PowerHint": "INTERACTION", + "Node": "CPUBWHystTriggerCount", + "Duration": 0, + "Value": "0" + }, + { + "PowerHint": "INTERACTION", + "Node": "CPUBWHystLength", + "Duration": 0, + "Value": "0" + }, + { + "PowerHint": "INTERACTION", + "Node": "CPUBWHistMemory", + "Duration": 0, + "Value": "0" + }, + { + "PowerHint": "INTERACTION", + "Node": "CPUBWMinFreq", + "Duration": 0, + "Value": "3879" + }, + { + "PowerHint": "LAUNCH", + "Node": "EnergyAware", + "Duration": 3000, + "Value": "0" + }, + { + "PowerHint": "LAUNCH", + "Node": "CPUBigClusterMaxFreq", + "Duration": 3000, + "Value": "9999999" + }, + { + "PowerHint": "LAUNCH", + "Node": "CPUBigClusterMinFreq", + "Duration": 3000, + "Value": "9999999" + }, + { + "PowerHint": "LAUNCH", + "Node": "CPULittleClusterMinFreq", + "Duration": 3000, + "Value": "9999999" + }, + { + "PowerHint": "LAUNCH", + "Node": "CPUBWHystTriggerCount", + "Duration": 3000, + "Value": "0" + }, + { + "PowerHint": "LAUNCH", + "Node": "CPUBWHystLength", + "Duration": 3000, + "Value": "0" + }, + { + "PowerHint": "LAUNCH", + "Node": "CPUBWHistMemory", + "Duration": 3000, + "Value": "0" + }, + { + "PowerHint": "LAUNCH", + "Node": "CPUBWMinFreq", + "Duration": 3000, + "Value": "6881" + }, + { + "PowerHint": "LAUNCH", + "Node": "GPUForceClkOn", + "Duration": 3000, + "Value": "1" + }, + { + "PowerHint": "LAUNCH", + "Node": "GPUForceRailOn", + "Duration": 3000, + "Value": "1" + }, + { + "PowerHint": "LAUNCH", + "Node": "GPUIdleTimer", + "Duration": 3000, + "Value": "10000" + }, + { + "PowerHint": "EXPENSIVE_RENDERING", + "Node": "PowerHALRenderingState", + "Duration": 0, + "Value": "EXPENSIVE_RENDERING" + }, + { + "PowerHint": "EXPENSIVE_RENDERING", + "Node": "GPUMinFreq", + "Duration": 0, + "Value": "647000000" + }, + { + "PowerHint": "EXPENSIVE_RENDERING", + "Node": "GPUMaxFreq", + "Duration": 0, + "Value": "647000000" + }, + { + "PowerHint": "LOW_POWER", + "Node": "KernelBatterySaver", + "Duration": 0, + "Value": "Y" + }, + { + "PowerHint": "Flipendo", + "Node": "CPULittleClusterMaxFreq", + "Duration": 0, + "Value": "1113600" + }, + { + "PowerHint": "Flipendo", + "Node": "CPUBigClusterMaxFreq", + "Duration": 0, + "Value": "1401600" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "CPUBigClusterMaxFreq", + "Duration": 0, + "Value": "9999999" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "CPUBigClusterMinFreq", + "Duration": 0, + "Value": "9999999" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "CPULittleClusterMaxFreq", + "Duration": 0, + "Value": "9999999" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "CPULittleClusterMinFreq", + "Duration": 0, + "Value": "9999999" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "GPUMaxFreq", + "Duration": 0, + "Value": "647000000" + }, + { + "PowerHint": "FIXED_PERFORMANCE", + "Node": "GPUMinFreq", + "Duration": 0, + "Value": "647000000" + } + ] +} diff --git a/proprietary-files.txt b/proprietary-files.txt index 969bb669..5dab8b53 100644 --- a/proprietary-files.txt +++ b/proprietary-files.txt @@ -513,6 +513,12 @@ vendor/lib64/libOmxQcelp13Dec.so|5a8e892912cd56c74b72420ea4fea62918bf260e vendor/lib64/libOmxWmaDec.so|12f994f034be6249acf8f25306bce4a38405e099 vendor/lib64/libmm-color-convertor.so|d7404046e5863a87922b35c3ff3edc5e76d6c249 +# Perf - from LA.UM.8.6.2.r1-08600-89xx.0 +vendor/lib64/libadaptlaunch.so|cf784401fc827e5195d595a6d855ec89ea8c22bf +vendor/lib64/libappclassifier.so|d5956c2dc9344ddcca0e78d84c393320c2e0cc97 +vendor/lib64/libgameoptfeature.so|b135489d253f0a8d7884238fe7887eb85b87745d +vendor/lib64/liblearningmodule.so|a9390d0ef1ec82c97a61035ec686c1d094fdca98 + # Peripheral - from ginkgo V12.5.1.0.RCOCNXM vendor/bin/pm-proxy|8e159d1fb25f5ee24cf94be8534b3bb8891831bc vendor/bin/pm-service|951e322c67132fe8826648e4fda9ddf5e4304e8a diff --git a/rootdir/Android.mk b/rootdir/Android.mk index b749475e..36d1ee41 100644 --- a/rootdir/Android.mk +++ b/rootdir/Android.mk @@ -129,11 +129,3 @@ LOCAL_MODULE_CLASS := ETC LOCAL_SRC_FILES := etc/init.verity.rc LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR_ETC)/init/hw include $(BUILD_PREBUILT) - -include $(CLEAR_VARS) -LOCAL_MODULE := init.qcom.power.rc -LOCAL_MODULE_TAGS := optional -LOCAL_MODULE_CLASS := ETC -LOCAL_SRC_FILES := etc/init.qcom.power.rc -LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR_ETC)/init/hw -include $(BUILD_PREBUILT) diff --git a/rootdir/etc/init.qcom.power.rc b/rootdir/etc/init.qcom.power.rc deleted file mode 100644 index 5d27bc5e..00000000 --- a/rootdir/etc/init.qcom.power.rc +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2012-2013, 2016-2020, The Linux Foundation. All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# * Neither the name of The Linux Foundation nor -# the names of its contributors may be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -# NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# - -on enable-low-power - # Enable PowerHAL hint processing - setprop vendor.powerhal.init 1 - -on property:sys.boot_completed=1 - trigger enable-low-power - - # Runtime fs tuning - write /sys/block/sda/queue/nr_requests 128 - write /sys/block/sda/queue/iostats 1 - - # Block layer tuning: discard chunk size up to 128MB - # Otherwise, contiguous discards can be merged - write /sys/block/sda/queue/discard_max_bytes 134217728 - - # Back to default VM settings - write /proc/sys/vm/dirty_expire_centisecs 3000 - write /proc/sys/vm/dirty_background_ratio 10 - - # Setup runtime cpusets - write /dev/cpuset/top-app/cpus 0-7 - write /dev/cpuset/foreground/cpus 0-3,5-6 - write /dev/cpuset/background/cpus 0-1 - write /dev/cpuset/system-background/cpus 0-3 - write /dev/cpuset/restricted/cpus 0-3 - - # Setup runtime blkio - # value for group_idle is us - write /dev/blkio/blkio.weight 1000 - write /dev/blkio/background/blkio.weight 200 - write /dev/blkio/blkio.group_idle 2000 - write /dev/blkio/background/blkio.group_idle 0 - -on early-init - # configure governor settings - write /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor schedutil - write /sys/devices/system/cpu/cpu0/cpufreq/schedutil/up_rate_limit_us 500 - write /sys/devices/system/cpu/cpu0/cpufreq/schedutil/down_rate_limit_us 20000 - -on init - # Boot time cpuset and stune - write /dev/cpuset/top-app/cpus 0-7 - write /dev/cpuset/foreground/cpus 0-7 - write /dev/cpuset/background/cpus 0-5 - write /dev/cpuset/system-background/cpus 0-5 - write /dev/cpuset/restricted/cpus 2-5 - - # Boot time fs tuning - write /sys/block/sda/queue/iostats 0 - write /sys/block/sda/queue/scheduler cfq - write /sys/block/sda/queue/iosched/slice_idle 0 - write /sys/block/sda/queue/nr_requests 256 - - # Disable powersaving - write /sys/module/lpm_levels/parameters/sleep_disabled 1 - - # bring back all cores - write /sys/devices/system/cpu/cpu0/online 1 - write /sys/devices/system/cpu/cpu1/online 1 - write /sys/devices/system/cpu/cpu2/online 1 - write /sys/devices/system/cpu/cpu3/online 1 - write /sys/devices/system/cpu/cpu4/online 1 - write /sys/devices/system/cpu/cpu5/online 1 - write /sys/devices/system/cpu/cpu6/online 1 - write /sys/devices/system/cpu/cpu7/online 1 - - # report max frequency to unity tasks. - write /proc/sys/kernel/sched_lib_name "UnityMain,libunity.so" - write /proc/sys/kernel/sched_lib_mask_force 255 diff --git a/rootdir/etc/init.qcom.rc b/rootdir/etc/init.qcom.rc index 743dff79..d84906fb 100755 --- a/rootdir/etc/init.qcom.rc +++ b/rootdir/etc/init.qcom.rc @@ -30,7 +30,6 @@ import /vendor/etc/init/hw/init.msm.usb.configfs.rc import /vendor/etc/init/hw/init.target.rc import /vendor/etc/init/hw/init.device.rc import /vendor/etc/init/hw/init.xiaomi_parts.rc -import /vendor/etc/init/hw/init.qcom.power.rc on early-init mount tracefs tracefs /sys/kernel/tracing @@ -522,6 +521,11 @@ service vendor.sensors.qti /vendor/bin/sensors.qti user system group system +# Adjust socket buffer to enlarge TCP receive window for high bandwidth +# but only if ro.data.large_tcp_window_size property is set. +#on property:ro.data.large_tcp_window_size=true +# write /proc/sys/net/ipv4/tcp_adv_win_scale 2 + on property:sys.sysctl.tcp_adv_win_scale=* write /proc/sys/net/ipv4/tcp_adv_win_scale ${sys.sysctl.tcp_adv_win_scale} @@ -638,6 +642,10 @@ service qvop-daemon /vendor/bin/qvop-daemon user system group system drmrpc +#on property:ro.data.large_tcp_window_size=true +# # Adjust socket buffer to enlarge TCP receive window for high bandwidth (e.g. DO-RevB) +# write /proc/sys/net/ipv4/tcp_adv_win_scale 2 + service hostapd_fst /vendor/bin/hw/hostapd -dd -g /data/vendor/wifi/hostapd/global class main capabilities NET_ADMIN NET_RAW diff --git a/sdm660.mk b/sdm660.mk index 30b54fb9..0fb26fe4 100644 --- a/sdm660.mk +++ b/sdm660.mk @@ -303,8 +303,6 @@ PRODUCT_PACKAGES += \ init.target.rc \ init.xiaomi_parts.rc \ init.verity.rc \ - init.fingerprint.rc \ - init.qcom.power.rc \ ueventd.qcom.rc # FM @@ -435,17 +433,22 @@ PRODUCT_COPY_FILES += \ frameworks/native/data/etc/android.software.opengles.deqp.level-2020-03-01.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.software.opengles.deqp.level.xml \ frameworks/native/data/etc/android.hardware.ethernet.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.ethernet.xml -# Perfd +# Perfd (dummy) PRODUCT_PACKAGES += \ libqti-perfd-client # Power PRODUCT_PACKAGES += \ - android.hardware.power-service.xiaomi-libperfmgr + android.hardware.power-service.xiaomi_sdm660-libperfmgr # Powerhint -PRODUCT_COPY_FILES += \ - $(COMMON_PATH)/configs/powerhint/powerhint.json:$(TARGET_COPY_OUT_VENDOR)/etc/powerhint.json +ifeq ($(EAS_POWERHINT_VARIANT), sdm636) + PRODUCT_COPY_FILES += \ + $(COMMON_PATH)/power-libperfmgr/sdm636_powerhint.json:$(TARGET_COPY_OUT_VENDOR)/etc/powerhint.json +else + PRODUCT_COPY_FILES += \ + $(COMMON_PATH)/power-libperfmgr/sdm660_powerhint.json:$(TARGET_COPY_OUT_VENDOR)/etc/powerhint.json +endif # Preopt SystemUI PRODUCT_DEXPREOPT_SPEED_APPS += \ @@ -479,6 +482,11 @@ $(call inherit-product, external/json-c/Android.configure.mk) PRODUCT_PACKAGES += \ libjson +# QTI Performance +PRODUCT_COPY_FILES += \ + $(COMMON_PATH)/configs/perf/perf-profile0.conf:$(TARGET_COPY_OUT_VENDOR)/etc/perf/perf-profile0.conf \ + $(COMMON_PATH)/configs/perf/perfconfigstore.xml:$(TARGET_COPY_OUT_VENDOR)/etc/perf/perfconfigstore.xml + # RIL PRODUCT_PACKAGES += \ librmnetctl \ diff --git a/sepolicy/vendor/file.te b/sepolicy/vendor/file.te index 96b8c7ff..ff8bc000 100644 --- a/sepolicy/vendor/file.te +++ b/sepolicy/vendor/file.te @@ -29,9 +29,3 @@ type sysfs_battery_saver, fs_type, sysfs_type; # PowerHAL type proc_sched_energy_aware, proc_type, fs_type; -type debugfs_sched_features, debugfs_type, fs_type; -type debugfs_wlan, debugfs_type, fs_type; -type proc_sysctl_schedboost, proc_type, fs_type; -type sysfs_msm_subsys, sysfs_type, fs_type; -type sysfs_rpm, sysfs_type, fs_type; -type sysfs_system_sleep_stats, sysfs_type, fs_type; diff --git a/sepolicy/vendor/file_contexts b/sepolicy/vendor/file_contexts index 8c2f2614..997629f4 100644 --- a/sepolicy/vendor/file_contexts +++ b/sepolicy/vendor/file_contexts @@ -68,7 +68,7 @@ /sys/devices/platform/soc/800f000.qcom,spmi/spmi-0/spmi0-03/800f000.qcom,spmi:qcom,pm660l@3:qcom,leds@d300/leds/flashlight(/.*)? u:object_r:sysfs_graphics:s0 # Power -/vendor/bin/hw/android\.hardware\.power-service\.xiaomi-libperfmgr u:object_r:hal_power_default_exec:s0 +/(vendor|system/vendor)/bin/hw/android\.hardware\.power-service\.xiaomi_sdm660-libperfmgr u:object_r:hal_power_default_exec:s0 # Root files /proc/sys/fs/protected_regular u:object_r:proc:s0 diff --git a/sepolicy/vendor/genfs_contexts b/sepolicy/vendor/genfs_contexts index b73f274b..1623a64c 100644 --- a/sepolicy/vendor/genfs_contexts +++ b/sepolicy/vendor/genfs_contexts @@ -41,9 +41,6 @@ genfscon sysfs /devices/virtual/graphics/fb0 genfscon sysfs /devices/virtual/graphics/fb1 u:object_r:sysfs_graphics:s0 genfscon sysfs /devices/virtual/graphics/fb2 u:object_r:sysfs_graphics:s0 -# Graphics -genfscon sysfs /devices/virtual/graphics/fb0/idle_state u:object_r:sysfs_graphics:s0 - # LED genfscon sysfs /devices/platform/soc/800f000.qcom,spmi/spmi-0/spmi0-03/800f000.qcom,spmi:qcom,pm660l@3:qcom,leds@d000/leds/button-backlight u:object_r:sysfs_graphics:s0 genfscon sysfs /devices/platform/soc/800f000.qcom,spmi/spmi-0/spmi0-03/800f000.qcom,spmi:qcom,pm660l@3:qcom,leds@d000/leds/button-backlight1 u:object_r:sysfs_graphics:s0 @@ -52,16 +49,13 @@ genfscon sysfs /devices/platform/soc/800f000.qcom,spmi/spmi-0/spmi0-03/800f000.q genfscon sysfs /devices/platform/soc/800f000.qcom,spmi/spmi-0/spmi0-03/800f000.qcom,spmi:qcom,pm660l@3:qcom,leds@d000/leds u:object_r:sysfs_graphics:s0 # Power +genfscon sysfs /devices/platform/soc/soc:qcom,gpubw u:object_r:sysfs_devfreq:s0 +genfscon sysfs /devices/platform/soc/soc:qcom,cpubw u:object_r:sysfs_devfreq:s0 +genfscon sysfs /devices/platform/soc/soc:qcom,mincpubw u:object_r:sysfs_devfreq:s0 genfscon sysfs /devices/platform/soc/soc:qcom,memlat-cpu0 u:object_r:sysfs_devfreq:s0 genfscon sysfs /devices/platform/soc/soc:qcom,memlat-cpu4 u:object_r:sysfs_devfreq:s0 genfscon proc /sys/kernel/sched_energy_aware u:object_r:proc_sched_energy_aware:s0 -# Power -genfscon debugfs /sched_features u:object_r:debugfs_sched_features:s0 -genfscon proc /sys/kernel/sched_boost u:object_r:proc_sysctl_schedboost:s0 -genfscon sysfs /power/rpmh_stats/master_stats u:object_r:sysfs_rpm:s0 -genfscon sysfs /power/system_sleep/stats u:object_r:sysfs_system_sleep_stats:s0 - # Touchpanel genfscon sysfs /touchpanel u:object_r:sysfs_touchpanel:s0 @@ -73,14 +67,3 @@ genfscon sysfs /devices/platform/soc/ca0c000.qcom,cci/ca0c000.qcom,cci:qcom,came genfscon sysfs /devices/platform/soc/ca0c000.qcom,cci/ca0c000.qcom,cci:qcom,camera@1/video4linux/video3/wakeup u:object_r:sysfs_wakeup:s0 genfscon sysfs /devices/platform/soc/ca0c000.qcom,cci/ca0c000.qcom,cci:qcom,camera@2/video4linux/video4/wakeup u:object_r:sysfs_wakeup:s0 genfscon sysfs /devices/virtual/input/input1/wakeup u:object_r:sysfs_wakeup:s0 - -# Subsystem -genfscon sysfs /devices/platform/soc/soc:qcom,cpubw u:object_r:sysfs_msm_subsys:s0 -genfscon sysfs /devices/platform/soc/soc:qcom,gpubw u:object_r:sysfs_msm_subsys:s0 -genfscon sysfs /devices/platform/soc/soc:qcom,l3-cpu0 u:object_r:sysfs_msm_subsys:s0 -genfscon sysfs /devices/platform/soc/soc:qcom,l3-cpu4 u:object_r:sysfs_msm_subsys:s0 -genfscon sysfs /devices/platform/soc/soc:qcom,llccbw u:object_r:sysfs_msm_subsys:s0 -genfscon sysfs /devices/platform/soc/soc:qcom,mincpubw u:object_r:sysfs_msm_subsys:s0 - -# Wi-Fi -genfscon debugfs /wlan0 u:object_r:debugfs_wlan:s0 diff --git a/sepolicy/vendor/hal_power_default.te b/sepolicy/vendor/hal_power_default.te index 89db80a9..03d161b6 100644 --- a/sepolicy/vendor/hal_power_default.te +++ b/sepolicy/vendor/hal_power_default.te @@ -22,29 +22,3 @@ allow hal_power_default self:capability { sys_nice sys_admin }; # Set scheduling info for system_server (for adpf) allow hal_power_default system_server:process setsched; - -allow hal_power_default input_device:dir r_dir_perms; -allow hal_power_default input_device:chr_file rw_file_perms; - -allow hal_power_default sysfs_graphics:dir search; -allow hal_power_default sysfs_graphics:file r_file_perms; - -allow hal_power_default sysfs_rpm:file r_file_perms; -allow hal_power_default sysfs_system_sleep_stats:file r_file_perms; - -allow hal_power_default debugfs_wlan:dir r_dir_perms; -allow hal_power_default debugfs_wlan:file r_file_perms; - -# To do powerhint on nodes defined in powerhint.json -allow hal_power_default sysfs_devfreq:dir search; -allow hal_power_default sysfs_devfreq:file rw_file_perms; -allow hal_power_default sysfs_kgsl:lnk_file read; -allow hal_power_default sysfs_kgsl:file rw_file_perms; -allow hal_power_default sysfs_msm_subsys:dir search; -allow hal_power_default sysfs_msm_subsys:file rw_file_perms; -allow hal_power_default sysfs_devices_system_cpu:file rw_file_perms; -allow hal_power_default device_latency:chr_file rw_file_perms; -allow hal_power_default cgroup:dir search; -allow hal_power_default cgroup:file rw_file_perms; -allow hal_power_default debugfs_sched_features:file rw_file_perms; -allow hal_power_default proc_sysctl_schedboost:file rw_file_perms;