text: // Generated from while_sum_of_powers_quant8_signed.mod.py
  // DO NOT EDIT
  // clang-format off
  #include "TestHarness.h"
  using namespace test_helper;
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_0() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_0 = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_0", get_test_model_n_0());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_0_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7},
                  .operands = {{ // param10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // x_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param65
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_0_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_0_all_inputs_as_internal", get_test_model_n_0_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_0_all_tensors_as_inputs() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {2, 4, 5},
                  .operands = {{ // param10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_0_all_tensors_as_inputs = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_0_all_tensors_as_inputs", get_test_model_n_0_all_tensors_as_inputs());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_0_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7, 10},
                  .operands = {{ // param10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_init_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param66
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // x_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param67
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {2},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {10, 11, 12},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_0_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_0_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_n_0_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_0_all_outputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param68
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // sum_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {6, 7, 8},
                              .outputs = {9},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {9}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_0_all_outputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_0_all_outputs_as_internal", get_test_model_n_0_all_outputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_1() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param25
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({15, 16}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_1 = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_1", get_test_model_n_1());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_1_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7},
                  .operands = {{ // param23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param25
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({15, 16}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // x5_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param72
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_1_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_1_all_inputs_as_internal", get_test_model_n_1_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_1_all_tensors_as_inputs() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {2, 4, 5},
                  .operands = {{ // param23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param25
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({15, 16}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_1_all_tensors_as_inputs = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_1_all_tensors_as_inputs", get_test_model_n_1_all_tensors_as_inputs());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_1_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7, 10},
                  .operands = {{ // param23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param25
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({15, 16}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_init1_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param73
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // x5_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param74
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {2},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {10, 11, 12},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_1_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_1_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_n_1_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_1_all_outputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param25
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param75
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // sum3_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({15, 16}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {6, 7, 8},
                              .outputs = {9},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {9}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out1
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_1_all_outputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_1_all_outputs_as_internal", get_test_model_n_1_all_outputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_2() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param36
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param37
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param38
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({2}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({19, 25}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param29
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param30
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param31
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param32
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param33
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param34
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param35
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param26
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param27
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param28
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_2 = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_2", get_test_model_n_2());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_2_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7},
                  .operands = {{ // param36
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param37
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param38
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({2}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({19, 25}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // x10_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param79
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param29
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param30
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param31
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param32
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param33
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param34
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param35
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param26
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param27
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param28
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_2_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_2_all_inputs_as_internal", get_test_model_n_2_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_2_all_tensors_as_inputs() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {2, 4, 5},
                  .operands = {{ // param36
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param37
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param38
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({2}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({19, 25}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param29
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param30
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param31
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param32
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param33
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param34
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param35
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param26
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param27
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param28
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_2_all_tensors_as_inputs = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_2_all_tensors_as_inputs", get_test_model_n_2_all_tensors_as_inputs());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_2_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7, 10},
                  .operands = {{ // param36
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param37
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param38
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({2}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({19, 25}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_init2_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param80
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // x10_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param81
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {2},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {10, 11, 12},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param29
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param30
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param31
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param32
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param33
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param34
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param35
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param26
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param27
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param28
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_2_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_2_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_n_2_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_2_all_outputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param36
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param37
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param38
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({2}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param82
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // sum6_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({19, 25}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {6, 7, 8},
                              .outputs = {9},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {9}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param29
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param30
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param31
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param32
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param33
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param34
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param35
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j5
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out2
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param26
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param27
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param28
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_2_all_outputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_2_all_outputs_as_internal", get_test_model_n_2_all_outputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_3() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param49
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param50
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param51
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({3}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({27, 52}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param42
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param43
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param44
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param45
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param46
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param47
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param48
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param39
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param40
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param41
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_3 = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_3", get_test_model_n_3());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_3_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7},
                  .operands = {{ // param49
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param50
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param51
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({3}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({27, 52}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // x15_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param86
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param42
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param43
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param44
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param45
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param46
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param47
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param48
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param39
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param40
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param41
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_3_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_3_all_inputs_as_internal", get_test_model_n_3_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_3_all_tensors_as_inputs() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {2, 4, 5},
                  .operands = {{ // param49
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param50
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param51
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({3}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({27, 52}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param42
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param43
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param44
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param45
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param46
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param47
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param48
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param39
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param40
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param41
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_3_all_tensors_as_inputs = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_3_all_tensors_as_inputs", get_test_model_n_3_all_tensors_as_inputs());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_3_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7, 10},
                  .operands = {{ // param49
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param50
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param51
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({3}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({27, 52}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_init3_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param87
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // x15_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param88
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {2},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {10, 11, 12},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param42
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param43
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param44
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param45
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param46
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param47
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param48
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param39
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param40
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param41
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_3_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_3_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_n_3_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_3_all_outputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param49
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param50
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param51
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({3}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param89
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // sum9_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({27, 52}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {6, 7, 8},
                              .outputs = {9},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {9}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param42
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param43
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param44
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param45
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi11
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param46
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param47
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param48
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j6
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi10
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j7
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i15
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out3
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param39
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param40
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param41
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_3_all_outputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_3_all_outputs_as_internal", get_test_model_n_3_all_outputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_4() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param62
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param63
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param64
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({4}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({43, 127}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param55
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param56
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param57
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param58
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param59
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param60
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param61
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param52
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param53
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param54
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_4 = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_4", get_test_model_n_4());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_4_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7},
                  .operands = {{ // param62
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param63
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param64
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({4}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({43, 127}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // x20_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder28
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param93
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param55
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param56
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param57
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param58
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param59
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param60
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param61
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param52
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param53
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param54
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_4_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_4_all_inputs_as_internal", get_test_model_n_4_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_4_all_tensors_as_inputs() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {2, 4, 5},
                  .operands = {{ // param62
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param63
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param64
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({4}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({43, 127}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param55
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param56
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param57
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param58
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param59
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param60
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param61
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param52
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param53
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param54
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_4_all_tensors_as_inputs = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_4_all_tensors_as_inputs", get_test_model_n_4_all_tensors_as_inputs());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_4_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 7, 10},
                  .operands = {{ // param62
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param63
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param64
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({4}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({43, 127}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_init4_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder29
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param94
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // x20_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder30
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param95
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {7, 8, 9},
                              .outputs = {2},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {10, 11, 12},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }},
                  .outputIndexes = {6}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param55
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param56
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param57
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param58
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param59
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param60
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param61
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param52
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param53
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param54
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_4_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_4_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_n_4_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  namespace generated_tests::while_sum_of_powers_quant8_signed {
  
  const TestModel& get_test_model_n_4_all_outputs_as_internal() {
      static TestModel model = {
          .expectFailure = false,
          .expectedMultinomialDistributionTolerance = 0,
          .isRelaxed = false,
          .main = {
                  .inputIndexes = {4, 5},
                  .operands = {{ // param62
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param63
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({1}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // sum_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({13, 13}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param64
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({4}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x20
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({16, 18}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // placeholder31
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param96
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // sum12_new
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({43, 127}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }},
                  .operations = {{
                              .inputs = {0, 1, 2, 3, 4, 5},
                              .outputs = {6},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {6, 7, 8},
                              .outputs = {9},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {9}
              },
          .minSupportedVersion = TestHalVersion::V1_3,
          .referenced = {{ // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i16
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x21
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS_EQUAL
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // sum14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i17
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // n14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x22
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 2,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // sum_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // i_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // zero4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({12, 12}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param55
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // xi_init4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param56
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({2}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param57
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<uint32_t>({3}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::SUBGRAPH,
                              .zeroPoint = 0
                          }, { // param58
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // xi14
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // param59
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param60
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param61
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {3, 6, 7},
                              .outputs = {8},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {9, 10, 8, 11, 1, 3},
                              .outputs = {12},
                              .type = TestOperationType::WHILE
                          }, {
                              .inputs = {1, 13, 14},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }, {
                              .inputs = {0, 12, 15},
                              .outputs = {4},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi12
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j8
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i18
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x23
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // out9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<bool8>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_BOOL8,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {1, 2},
                              .outputs = {4},
                              .type = TestOperationType::LESS
                          }},
                  .outputIndexes = {4}
              }, { // param
                  .inputIndexes = {0, 1, 2, 3},
                  .operands = {{ // xi13
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j9
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // i19
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // x24
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // xi_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int8_t>({}),
                              .dimensions = {1, 2},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 1.0f,
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .zeroPoint = 12
                          }, { // j_out4
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param52
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }, { // param53
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({1}),
                              .dimensions = {1},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::TENSOR_INT32,
                              .zeroPoint = 0
                          }, { // param54
                              .channelQuant = {},
                              .data = TestBuffer::createFromVector<int32_t>({0}),
                              .dimensions = {},
                              .isIgnored = false,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .type = TestOperandType::INT32,
                              .zeroPoint = 0
                          }},
                  .operations = {{
                              .inputs = {0, 3, 6},
                              .outputs = {4},
                              .type = TestOperationType::MUL
                          }, {
                              .inputs = {1, 7, 8},
                              .outputs = {5},
                              .type = TestOperationType::ADD
                          }},
                  .outputIndexes = {4, 5}
              }}
      };
      return model;
  }
  
  const auto dummy_test_model_n_4_all_outputs_as_internal = TestModelManager::get().add("while_sum_of_powers_quant8_signed_n_4_all_outputs_as_internal", get_test_model_n_4_all_outputs_as_internal());
  
  }  // namespace generated_tests::while_sum_of_powers_quant8_signed
  
  